When running unattended Android monkey tests, unexpected WiFi shutdowns can disrupt results, so this guide shows how to build a lightweight Java app that checks WiFi status every minute and toggles it every ten minutes using ADB commands to keep the network stable.
This tutorial shows how to clone a sample Android Gradle repository, build both debug and release APKs using the Gradle wrapper, and upload the generated packages to the Fir platform for testing on mobile devices.
This tutorial explains how to download and install JDK 8, set up Android SDK tools, install Gradle, and configure environment variables on a Linux system, including verification commands and a brief FAQ for common issues.
This guide explains how to set up Android project packaging paths, write Python upload scripts for fir.im and Pgyer, configure a Jenkinsfile with checkout, build, and upload stages, and define Jenkins global variables and parameters for automated CI/CD of mobile apps.
This article details how Baidu App reduced the landing‑page first‑screen load from over 2600 ms to under 2000 ms by analyzing user feedback, instrumenting each loading stage of its Hybrid H5 solution, and applying a series of backend‑direct‑output, prefetch, WebView pre‑creation, lazy‑load and kernel‑level rendering optimizations together with code‑level fixes.
This article presents a real‑device performance test of three data serialization structures—JSON, Protocol Buffers, and FlatBuffers—used in H5‑Hybrid and Flutter development, analyzing their size, serialization/deserialization speed, and suitability for Android, Flutter, and H5 communication channels.
To avoid test failures caused by being logged into an unintended account, the author implements a recursive login routine in an Android UiAutomator script that checks the current user, logs out if necessary, and re‑logs in with the correct credentials, illustrating a concise and reusable testing solution.
The article explains why the Java compiler generates synthetic access$xxx methods for inner‑class field access, describes their negative impact on dex size, multidex, APK size and performance, and details a practical ASM‑based approach to safely eliminate them while handling related Dalvik bugs.
ARetrofit is an Android routing framework that enables concise, component‑to‑component communication by generating compile‑time route metadata via annotation processing, injecting bytecode with the Transform API, creating service proxies through dynamic proxies, and applying an OkHttp‑style interceptor chain for flexible, cross‑module extensions.
The article presents YouZan’s hybrid integration strategy that packages each Flutter feature as an independent artifact—AAR files for Android and frameworks for iOS—allowing native teams to embed Flutter modules via simple scripts and Maven uploads without needing a full Flutter development environment.
This comprehensive guide explains what Flutter plugins are, why they are essential, the MethodChannel communication model, step‑by‑step plugin creation, common pitfalls, testing strategies, publishing to public or private repositories, and a real‑world case study of a routing plugin, providing all the code and configuration details developers need to build and distribute their own Flutter plugins.
This article details the background, challenges, and step‑by‑step solution for standardizing UI across Youzan Retail’s iOS and Android apps, covering designer and developer perspectives, the creation of a shared style library, component architecture, resource management, delivery outcomes, pitfalls, and future automation plans.
This article explains how to perform ordered UI traversal of an Android application with UIAutomator on the 360 Open Testing platform, covering required parameters, a seven‑step implementation process, UI change listening via AccessibilityService, element dumping, sorting, comparison methods, interaction automation, and termination conditions.
Xianyu integrated accessibility directly into its Flutter‑Native hybrid app, establishing a systematic workflow—from design to monitoring—that makes all interactive elements focusable, described, and properly ordered, enabling over 40 000 visually impaired users to navigate the marketplace with an 87.5% issue‑fix rate.
This article provides an in‑depth examination of Android's ClassLoader architecture, explaining how BaseDexClassLoader.findClass() and ClassLoader.loadClass() locate and load classes, with step‑by‑step source code analysis of loadClass, findLoadedClass, findClass, DexPathList, DexFile, and native class definition processes.
This article explains the concept and practical application of the Annotation Processing Tool (APT) in Android development, demonstrating how to set up an APT project, define annotations, process them with custom processors, and automatically generate Java code for activity navigation using JavaPoet.
The article details how the Youzan Mobile Assistant adds a local packet‑capture module that leverages Android VpnService/iOS NetworkExtension and tun2socks to route traffic through a SOCKS5 proxy, then uses Socket.IO to push request and response data in real time to the app’s UI while keeping the app alive in the background.
Recent reports reveal that many Android apps secretly collect location and identifier data despite denied permissions, a zero‑day Zoom flaw lets any website hijack Mac cameras, and Didi adjusts its pricing, while a man released after splashing water on Baidu's CEO highlights broader tech‑related news.
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.
