This article explains why Android only supports Vector drawables, explores how to load and render SVG files using AndroidSVG, Glide, and PathView, discusses custom SvgDrawable attempts, introduces iconfont for vector icons, and provides a comprehensive comparison of Android vector graphic solutions.
This guide outlines comprehensive performance indicators for Android and iOS apps—including startup time, page load speed, responsiveness, resource consumption, stability, network efficiency, interaction quality, background task handling, installation, compatibility, security, and low‑end device adaptation—providing industry‑standard thresholds for each metric.
This guide explores Android's inter‑process communication options—running services in separate processes, defining AIDL interfaces, using explicit and implicit Intents, BroadcastReceiver, Messenger, FileProvider, and ContentProvider—detailing configuration, code examples, and when to choose each method for efficient, secure component interaction.
This article walks through implementing sophisticated like-button animations for a news client on HarmonyOS using ArkUI, compares the approach with Android's animation framework, explains key ArkUI APIs like animateTo, and provides detailed Kotlin and TypeScript code for property and Bezier curve animations.
This article reveals how seemingly harmless static variables in Java can become hidden memory killers, illustrates real-world crashes caused by static caches and configuration, and provides three practical techniques—including weak references, lifecycle‑bound clearing, and leak‑detection tools—to prevent memory leaks in Android and backend applications.
Google announced that it will combine Android and ChromeOS into a single platform, aiming to unify ecosystems, boost app performance, and create seamless cross‑device experiences, while facing architectural and user‑experience challenges that could reshape the future of personal computing.
This article explains how Android handles SVG-like vector graphics using VectorDrawable and AnimatedVectorDrawable, covering their XML structures, supported tags, code examples, conversion from SVG, usage in layouts, and a detailed source code walkthrough of rendering and animation processes.
Apple’s newly announced Swift Android Workgroup aims to bring Swift natively to Android, sparking industry debate over a potential shift in mobile development, the strategic motivations behind Apple’s move, Kotlin’s response, and the broader impact on developers’ skill sets and career prospects.
This article explains how to create a web‑based Android terminal by combining ADB, a persistent socket connection, node‑pty, and xterm.js, enabling remote device management, command execution, and file operations for IoT and development scenarios.
This article dissects Android’s task scheduling challenges by correcting misconceptions about virtual runtime, detailing load‑normalization using WAL‑T, deriving a frequency‑aware task_load formula, exposing the chicken‑egg problem between load and frequency, and exploring priority inversion and rtmutex as a mitigation strategy.
This article examines the most frequent side‑effect errors developers make in Jetpack Compose, explains why each mistake leads to performance or correctness issues, and provides clear, code‑driven solutions to help both beginners and seasoned Android developers write efficient, reliable UI code.
This article compares Kotlin Channel and Flow, explains their design differences, outlines when to prefer each tool, provides step‑by‑step usage instructions, showcases four channel types, presents real‑world Android examples, and covers advanced patterns and exception handling for robust coroutine communication.
This article compares Kotlin Channel and Flow, explains their distinct characteristics, shows when to prefer each in Android coroutine programming, provides step‑by‑step usage, multiple channel implementations, real‑world examples, advanced fan‑in/fan‑out patterns, and robust exception handling.
This article details the design and implementation of a native Android image‑editing component built for warehouse quality‑inspection, covering business motivations, core features such as multi‑image batch editing, matrix‑based transformations, a command‑pattern undo/redo system, technical architecture, key challenges, and future extension plans.
This article explains how to reduce Unreal Engine Android package size and native library memory usage by applying a series of build‑time and resource‑trimming strategies—including native lib compression, code size reduction, relocation table compression, and selective asset packaging—while preserving runtime performance.
This article examines the origins, core principles, and practical implementation of the Model‑View‑Intent (MVI) pattern in Android, clarifies common misconceptions with Redux and MVVM, and provides Kotlin code examples and guidelines for building robust, unidirectional, immutable state architectures.
This article details ZhiZhuan Group's end‑to‑end code‑coverage system for Android and iOS apps, covering its background, design, incremental instrumentation, CI/CD integration, optimization steps, visual reporting, and real‑world impact, offering practical insights for mobile development teams seeking reliable test coverage.
This guide explains how to create a custom Android boot animation using frame sequences, package it correctly, compress it, replace it via ADB, and also covers modifying or hiding the Linux kernel and bootloader logos, including required tools, file formats, and safety precautions.
This article explains the concept of Hook in Android, demonstrates how to intercept View OnClickListener and startActivity using Java reflection and instrumentation, and introduces the Xposed framework for system‑wide method hooking, providing step‑by‑step code examples and practical deployment tips.
This article introduces ovCompose and KuiklyBase, Tencent Video's cross‑platform development framework built on Compose Multiplatform, explains the background, key advantages, implementation details, performance optimizations for Android, iOS and HarmonyOS, provides repository information and outlines future plans.
Google AI Edge Gallery lets a 2 GB RAM Android phone run sophisticated multimodal AI models completely offline, offering image understanding, text generation, and conversational capabilities without any network connection, and provides a quick three‑step setup to start experimenting with on‑device AI.
This article explains the problem of internal and external memory fragmentation in Linux systems, introduces eBPF as a powerful tracing tool, and provides step‑by‑step guidance for building, loading, and running eBPF programs to analyze and mitigate fragmentation on both Linux and Android platforms.
This article explains the limitations of the original Jetpack Navigation library for Compose, introduces the new Nav3 architecture with its custom back‑stack, open design, and modular components, and demonstrates key features and a code sample for modern Android UI development.
This article highlights five common Kotlin coroutine pitfalls for Android developers—directly calling suspend functions in Views, misusing GlobalScope, sequential network calls, improper exception handling, and ignoring cancellation—while providing correct implementations and best‑practice guidelines to avoid them.
This article details three major optimization directions—component scheduling, component reuse, and component governance—applied to Taobao live streaming, explaining the technical redesign, task scheduler implementation, RecyclerView view‑holder reuse, performance gains, and future improvement plans.
Android only supports Vector drawables, but many apps need to display server‑delivered SVGs; this article compares several approaches—including AndroidSVG, Glide integration, PathView, custom SvgDrawable, and IconFont—detailing setup, code snippets, rendering pipelines, animation limits, and practical recommendations for mobile developers.
This article details how Vivo’s official app implements edge intelligence to dynamically rank and recommend hardware products on its homepage, covering problem abstraction, data collection, feature engineering, model design, TensorFlow‑Lite conversion, on‑device inference, and monitoring for a personalized user experience.
This article provides a comprehensive guide for Android developers on how to connect and use serial ports, USB peripherals, printers, barcode scanners, payment boxes, keyboards, and mice, including required permissions, configuration steps, and sample Kotlin/Java code snippets for each device type.
This article explains eBPF from a developer's perspective, covering the eBPF virtual machine, instruction encoding, bytecode generation with LLVM/Clang, loading via the bpf() syscall, verifier rules, execution flow, JIT compilation, and how Android builds and packages eBPF programs.
This article explains multiple ways to display SVG graphics on Android, covering the AndroidSVG library, direct SVG rendering with SVGImageView, Glide integration for remote SVGs, the PathView animation library, custom drawable attempts, and iconfont usage, while comparing their pros and cons.
This article examines common challenges of sharing user interaction logic across multiple Android screens using ViewModel, compares four reuse strategies—including base class inheritance, helper classes, Kotlin class delegation, and interface default functions—and recommends the interface default‑function approach as the most flexible and maintainable solution.
From Google's early recruitment challenges to acquiring a tiny startup that built a Java‑based demo system, Android emerged as an open‑source mobile operating system, leveraging Dalvik, overcoming hardware competition, and ultimately dominating the global smartphone market through rapid development and strategic alliances.
This guide walks through using Frida to hook common Android methods, print stack traces, and extract runtime data, providing ready-to-use code snippets for functions like HashMap.put, ArrayList.add, TextUtils.isEmpty, Base64 encoding, and UI event handling.
This tutorial demonstrates how to reverse‑engineer the X‑Product Android app, locate the dynamic newSign parameter, hook the RequestUtils.c method with Frida, and expose it via an RPC‑based FastAPI service to generate valid signed requests for the search API.
This tutorial demonstrates how to use Frida to hook Java‑level encryption functions in Android apps, covering preparation utilities, self‑exfiltration of MD5, SHA1, MAC, DES/AES/RSA, and signature algorithms with detailed code snippets and visual examples.
This comprehensive tutorial walks through using Frida to hook Android applications, covering official API references, loading APKs, hooking normal and static methods, modifying parameters and return values, handling constructors, inner and anonymous classes, enumerating loaded classes and methods, dynamic dex loading, selective hooking, and practical examples such as programmatically clicking a login button, all illustrated with clear code snippets and explanations.
The article explains how to adopt a single‑Activity architecture in Jetpack Compose by using the Navigation component’s NavHost and NavController, encapsulating navigation calls in an Action class, and exposing module‑specific NavGraphs, resulting in a clean, scalable routing solution for modern Android apps.
The article explains Android’s VectorDrawable format for SVG‑like scalable graphics, details its XML schema, shows how to create static vectors, gradients, and clip‑paths, then examines the underlying source‑code flow, and finally describes AnimatedVectorDrawable’s property‑based animations, inflation process, and runtime execution.
This guide explains how to enable and disable ADB debugging, manage app permissions via ADB commands, and implement device‑level and application‑level encryption to enhance security on Android devices.
This tutorial walks you through setting up a Python virtual environment, installing Frida and frida‑server on a rooted Android device, configuring the server, verifying the connection, and writing JavaScript hooks to intercept login functions, complete with code snippets, command examples, and troubleshooting tips.
This guide explains how to use the Android Monkey tool to generate random user events for stress testing, configure its parameters for different testing scenarios, and analyze the resulting logs to identify crashes, ANRs, and event sequences that affect app stability.
This guide explains how to access Android SQLite databases via adb shell sqlite3, create and run complex shell scripts, and manage app permissions and users through ADB commands, providing practical examples for debugging and automation.
This guide explains how to use Android Debug Bridge (ADB) commands to install and uninstall APKs, list installed packages, and start or stop applications on a connected device, providing essential tools for mobile developers and testers.
Facing DeepSeek R1 server instability, the open‑source MNN LLM framework offers local, mobile‑friendly deployment with model quantization and hardware‑specific optimizations, dramatically improving inference speed, stability, and download reliability across Android, iOS, and desktop platforms while supporting multimodal inputs.
This guide explains essential ADB commands for Android development, covering how to reboot a device (including bootloader and recovery modes), view real‑time logs with logcat and its filtering options, and enter the device’s shell to run Linux commands such as ls, pwd, and top.
This guide explains what ADB (Android Debug Bridge) is, how to install JDK and the Android SDK, configure environment variables, enable USB debugging, and verify device connection using the adb devices command, providing a solid foundation for Android development and testing.
This article dissects ViewPager2's internal scrolling architecture, explains its core classes, orientation handling, PageTransformer workflow, scroll event processing, animation techniques, performance tweaks, and demonstrates how to recreate a complex advertising carousel with custom transformations and layout optimizations.
This guide explains how to use Android's Monkey tool with advanced options such as package whitelists and blacklists, event‑type weighting, crash ignoring, throttle settings, seed values, and integration with systrace to achieve more precise, efficient, and repeatable mobile app testing.
This guide explains how to monitor key system resources such as CPU, memory, battery, network traffic, and startup time during Android Monkey testing, provides ADB commands for data collection, and offers a structured test report template with practical steps for automation and analysis.
This guide outlines how to design a comprehensive Monkey testing strategy for Android apps, covering goal definition, event type selection, event count, throttling, option configuration, seed value setup for reproducibility, and practical command examples.
This tutorial explains what MonkeyRunner is, how to set up the environment, write Python scripts, connect to Android devices, install and launch apps, simulate user actions, capture screenshots, and clean up, providing a complete example script for automated mobile testing.
This guide explains the structure of Android Monkey test logs, highlights key information such as event counters and exception details, and provides practical solutions for common errors like ANR, crashes, OutOfMemoryError, and SecurityException, along with best practices for effective log analysis.
This article explains the various pseudo‑random event types that the Android Monkey tool can generate, shows the command‑line parameters for each type, and provides a sample ADB command to set custom event‑type percentages for more realistic mobile app stress testing.
Google announced that starting March 2025 it will close the Android Open Source Project, moving development to private branches, limiting real‑time public contributions, narrowing the open‑source scope, and potentially reshaping the mobile OS ecosystem while having limited immediate impact on major OEMs.
Learn how to use Android's Monkey command-line tool to generate pseudo‑random user events for stress testing, covering basic syntax, key parameters like -p, -v, --throttle, and --pct-touch, and how to interpret the output to identify crashes and performance issues.
Google announced that starting next week it will cease maintenance of the Android Open Source Project, shifting all Android development to internal branches, which means only Google employees can access AOSP, limiting external developers and ROM creators while having limited impact on major OEMs.
This article introduces Monkey testing on Android, explaining its purpose, key characteristics, and how to set up the environment and run basic tests using ADB commands to improve app stability and automate stress testing.
This article explains the fundamentals of ASM’s tree API for Java bytecode manipulation, illustrates the structure of class files, fields, methods, and signatures, and provides a practical example of inserting code to rename anonymous Thread instances during the Transform phase.
Weaver enhances Android’s password‑unlock system by moving rate‑limiting and secret storage into a Secure Element, protecting the authentication secret when the device is off and throttling repeated guesses with hardware timers, thereby hardening GateKeeper/KeyMint against offline brute‑force attacks despite added OMAPI latency.
The article details four native DeWu Android client crashes—DNS resolution, MediaCodec state‑exception, BIO multi‑thread, and Xiaomi Android 15 focus null‑pointer—explains their root causes, and demonstrates inline‑hook, PLT‑hook, and JNI‑hook fixes that lowered the crash rate from 2/10 000 to about 1.2/10 000.
This tutorial explains how to capture any Android view—whether displayed, off‑screen, or generated programmatically—into a Bitmap, draw it with Canvas, and then save or share the resulting image, covering multiple view types and Android version compatibility.
UprobeStats, introduced in Android 15, uses the Linux kernel eBPF uprobe mechanism to dynamically insert probes into user‑space methods, capture timestamps and arguments, load BPF programs, and forward the data to StatsD via configurable protobufs, enabling flexible, source‑free instrumentation with minimal overhead.
This article compares the traditional Xposed‑based dynamic privacy checker with a new Gradle‑plugin instrumentation approach, explains the design and implementation of the Transform API‑driven solution, shows performance metrics, provides usage instructions, and outlines automated testing and future improvements for Android apps.
This guide walks through setting up Appium with the UiAutomator2 driver, verifying the environment, writing a Python script that connects to the Appium server, using weditor or uiautomatorviewer to inspect Android UI elements, and applying ID or XPath locators to automate clicks in the Zepp app.
The black‑flash in Taobao’s shopping‑cart tab occurs because SurfaceView’s independent surface is destroyed during fragment removal or activity switches, and four remedies are offered: keep the fragment alive with show/hide, capture and display a screenshot, toggle between ImageView and SurfaceView via Weex APIs, or convert SurfaceView to TextureView temporarily, each with performance, memory, and latency trade‑offs.
The article examines why Android fragment transition animations lag compared to activity animations and proposes three remedies—delaying heavy UI work, feeding data frame‑by‑frame via Choreographer callbacks, and using an asynchronous SurfaceView snapshot—to achieve smoother, deterministic UI performance on low‑end devices.
This article outlines five common Android SDK development methods—Jar, SO, AAR, Dex‑plugin, and Apk‑installation—detailing their structures, integration steps, code examples, and best‑practice principles such as stability, minimal dependencies, small package size, optimal performance, compatibility, and dynamic updatability.
This article explains Android's NestedScrolling mechanism introduced in Android 5.0, detailing the parent‑child interaction flow, key interfaces (NestedScrollingParent and NestedScrollingChild), helper classes, and provides Kotlin/Java code examples for custom views and RecyclerView integration.
The article explains the principles of dependency injection, compares the DI frameworks Koin and Hilt in terms of integration difficulty, performance, cross‑platform support, IDE tooling, and maintenance, and concludes that Koin offers a simpler, lighter, and more versatile solution for Android and multiplatform projects.
This article presents a comprehensive guide on building a highly modular Android network layer by leveraging Kotlin coroutines, Flow, Retrofit, annotation processors, dynamic proxies, and dependency‑injection frameworks to automatically generate Repository classes and streamline MVVM data flow.
Twitter’s Compose static‑analysis guide defines a comprehensive set of lint rules—covering state hoisting, proper use of remember, @Immutable annotations, stable collections, safe parameter passing, single‑layout emission, naming conventions for locals, previews and functions, and mandatory Modifier handling—to help large teams write clean, performant Jetpack Compose code.
The Android DisplayManagerService (DMS) orchestrates detection, addition, configuration, and removal of physical and logical displays, handling multi‑user, virtual, split‑screen, foldable, and HDR scenarios through components such as DisplayDeviceRepository, LogicalDisplayMapper, adapters, and power controllers, all initialized by SystemServer.
This article provides a comprehensive introduction to Android NDK development, covering JNI fundamentals, data type mappings, method registration (static and dynamic), JNIEnv usage, CMake build configuration, and multiple practical code examples in Kotlin, C++, and C.
This article explains the limitations of the default Retrofit baseUrl configuration, reviews three existing solutions, and presents a comprehensive interceptor‑based approach that leverages custom @BaseUrl annotations to dynamically switch base URLs at runtime while handling @Url full‑path parameters correctly.
This article explains the concept of "same‑frequency same‑frame" animation, analyzes the limitations of existing animation engines, and presents a Drawable‑based projection technique with code examples to synchronize animation frames across multiple Android views while reducing memory and CPU overhead.
This guide demonstrates how to strip splash-screen ads from an Android game by decompiling the APK, locating and altering the launch activity in AndroidManifest.xml, and recompiling the app, offering a practical reverse-engineering workflow for mobile developers.
This article explains how to combine Kotlin coroutines, Flow, Retrofit, and OkHttp to create a clean, reactive, and maintainable network request framework for Android applications, covering concepts, core principles, and practical code examples.
This article demonstrates how to create a smooth color‑gradient animation for an Android view by dynamically configuring a GradientDrawable and driving the transition with a Kotlin PropertyAnimator, including code examples and step‑by‑step explanations.
This guide explains why Charles combined with Postern is preferred for Android app packet capture, details the required environment, step‑by‑step configuration of Charles and Postern, SSL proxy setup, certificate installation and migration, and compares the solution with Fiddler.
This article explains Airbnb’s Android Trio framework, focusing on Props—a Kotlin data‑class mechanism that lets parent pages safely pass mutable data and callbacks to child Compose pages, illustrated with inbox and Todo screen‑flow examples and complete code snippets.
This guide walks through preparing the Kivy development environment on macOS and CentOS, creating a simple hello‑world Python app, installing and using Buildozer to package the app for Android (and iOS), and troubleshooting common build issues with code examples and virtual‑machine recommendations.
This article reviews five high‑severity Android native vulnerabilities, detailing how missing length checks, unsigned integer wrap‑around, thread‑lifecycle misuse, unlocked vectors, and out‑of‑scope pointers lead to heap overflows or use‑after‑free bugs, and presents the remediation steps recommended by Google.
The article shows how Trio stores navigation state in a ViewModel‑backed stack, uses type‑safe routers for screen and activity transitions, supports async save‑and‑exit, result‑returning navigation, and interoperates with legacy fragments, enabling modular, testable navigation in Jetpack Compose.
This article explains the basic concepts of Android power consumption, the components that contribute to battery drain, the role of power_profile.xml, and various measurement methods such as PowerMonitor, dumpsys batterystats, system power ranking, and Battery Historian, providing practical steps and tools for developers to analyze and optimize app energy usage.
This article explains the fundamentals of Android power consumption, breaks down the components that drain battery, describes how to extract and interpret power profile files, and reviews practical measurement tools such as PowerMonitor, dumpsys batterystats, system power ranking, and Battery Historian to help developers optimize app energy usage.
APNG, a high‑quality animated PNG format offering 24‑bit color and 8‑bit alpha transparency, outperforms GIF in visual fidelity and file size, and on Android can be parsed and rendered via MappedByteBuffer and SurfaceView using background threads to load frames from memory, eliminating I/O lag and UI blocking.
This article analyzes a vulnerability in Android's FileSharingActivity that allows malicious apps to manipulate file-sharing intents, craft dangerous URIs and filenames, and ultimately overwrite sensitive data or execute arbitrary code, while also offering concrete mitigation strategies.
Ke Jie explains why reducing the Game Center APK—by eliminating alpha‑PNG images, unused code and resources, limiting language and density assets, disabling v1 signing, compressing images, loading native libraries on demand, shipping only 64‑bit binaries, enabling code/resource shrinking and R‑file inlining—cut size by about 31% (≈20 MB), boosting download conversion and launch performance.
Airbnb’s Android team introduced Trio, a Compose‑only framework built atop the Mavericks state‑management library that replaces Fragment‑based navigation with type‑safe, modular page routing, ViewModel‑driven state, compile‑time validation, and dedicated developer tools, now powering the majority of the app’s screens.
This article describes how Tubi's Android team redesigned their video player with a modular, distributed architecture—introducing PlayerContext, PlayerHandlerWrapper, and composable modules for ads, event tracking, and TTS—to improve flexibility, testability, and scalability while sharing lessons learned from the refactoring process.
BlockFramework is an open‑source Android client‑side framework that decouples business logic into reusable Blocks, offering clear separation, tree‑based UI assembly, rich communication patterns, unified development standards, and high‑performance features such as asynchronous view inflation and data binding.
This article chronicles the evolution of domestic Chinese mobile operating systems—from the early 2000s feature‑phone experiments, through the Android‑based custom ROM era, to the recent push for fully self‑developed platforms like HarmonyOS—highlighting key players, milestones, and the challenges that shaped the market.
Android Dynamic Performance Framework (ADPF) lets apps and games send performance‑hint data—such as target work durations and preferred cores—to the kernel, enabling faster CPU frequency scaling and priority scheduling that mitigates the latency of PELT/WALT and DCVS, while developers use APIs like createHintSession and reportActualWorkDuration, though adoption remains limited.
This article explains Bluetooth Low Energy fundamentals, compares classic and BLE, describes BLE mesh networking, provides a complete bleno example for peripheral simulation, and details advertising, scanning, connection flow, MTU negotiation, fragmentation, and sticky‑packet handling on Android and iOS.
This tutorial explains how to set up the Kivy development environment on macOS, Linux, and CentOS, create a simple hello‑world Python app, test it, install Buildozer, and use it to package the app into an Android APK (or iOS build), including common pitfalls and fixes.
Google is integrating a Linux‑compatible terminal into Android via the Android Virtualization Framework, allowing users to launch a Debian‑based VM directly from developer options and run Linux software on their phones without third‑party tools.
This article explains why a pre‑ads loading step is required for Android apps, analyzes the limitations of the current linear startup flow, and details several technical solutions—including system‑API checks, exclusion rules, handler hooking, and initialization reversal—to reliably detect icon‑click launches and reduce startup latency.
The US Department of Justice’s 2024 antitrust action against Google aims to dismantle its dominance in search, advertising, Chrome, Play Store, and Android, potentially forcing structural remedies that could reshape the tech giant’s AI‑driven ecosystem and market competition.
This guide introduces Alibaba Cloud ARMS RUM, explains its core capabilities, walks through Android and iOS SDK integration, permission and ProGuard setup, and demonstrates how to analyze sessions, resources, API calls, custom events, and logs to optimize user experience across cloud‑native applications.
The team maintains an ‘opt’ branch for daily‑collected crash fixes, classifies unrecoverable system, device, SDK and framework errors, and employs a Handler‑based whitelist that catches and swallows known crashes while logging others, complemented by null‑safety, concurrency, database and OOM monitoring to keep Android app crash rates manageable.
