This guide explains how to configure a Windows-based testing environment using Cygwin, install necessary tools, create shortcuts, access Windows drives, and execute shell scripts to record videos, extract frames, compare images, and calculate average response times for Android applications.
Despite widespread reliance on manual UI testing, this article details how the author’s team built an Espresso‑based test platform that achieves 80‑90% functional coverage, introduces the ETP design, explains single‑page testing, test flows, and shares practical solutions to common Espresso pitfalls.
The article explains Android’s APK Signature Scheme v2—introduced in Android Studio 2.2—its performance and integrity benefits over v1, details the signing block structure and verification steps, and demonstrates how to embed and retrieve custom channel data within the v2 block while preserving successful verification.
This guide explains how Android developers can understand APK structure and apply a range of techniques—such as removing unused resources, compressing images, using vector drawables, and optimizing native code—to significantly reduce the size of their application packages and improve download and install performance.
This article explains various multi‑channel packaging methods for Android APKs, compares traditional Gradle productFlavors and ApkTool approaches, and introduces efficient V1‑ and V2‑based channel insertion techniques that avoid rebuilding or re‑signing, while providing integration steps for the ApkChannelPackage plugin.
This article details the evolution of the Android Recorder used in the FluentSpeak app, covering API choices, AudioFocus handling, processing patterns, encountered challenges such as encoder blocking, testing difficulties, and native crashes, and presents solutions like ProcessThread, AudioProcessor abstraction, WavFileRecorder, and ServiceWrapper to improve reliability and extensibility.
This guide explains how to configure Jenkins to run Android Monkey tests on both emulators and real devices, covering plugin installation, build environment setup, parameterized builds, command-line options, and post-build result publishing for continuous integration of mobile stability testing.
The Meituan Android team traced a surge of OutOfMemoryError crashes to duplicated drawable caches created by the AppCompat vector‑from‑resources flag, reproduced the condition on OPPO N1 devices, used heap‑dump analysis to pinpoint oversized byte‑array allocations, and eliminated the issue by disabling the flag, dramatically cutting OOM incidents.
This article analyzes a frequent Android crash caused by posting delayed Runnables to a Handler, explains why it is hard to reproduce, and presents a solution that extends the delay to reliably trigger and then mitigate the issue using message‑queue manipulation.
This article explains the memory allocation and garbage‑collection mechanisms of Android’s Dalvik and ART runtimes, compares their algorithms, describes GC triggers, logs, and offers practical tips to reduce frame drops caused by frequent GC cycles.
This article explains the Android Soong build system, its JSON‑like Android.bp file format, module definitions, variables, comments, types, operators, default modules, formatting tools, conversion from Android.mk, build logic, and common questions for mobile developers.
This article outlines comprehensive Android naming and code style standards—including file encoding, class and method naming, resource naming, and comment conventions—to help development teams achieve consistent, maintainable code and improve collaboration efficiency.
To shrink Meituan’s Android APK, developers can optimize the ZIP layout, enable ProGuard/R8 dex shrinking, inline R fields, convert images to WebP or VectorDrawable, disable redundant PNG crunching, activate shrinkResources, limit packaged languages, obfuscate resources with tools like AndResGuard, and eliminate duplicate or unused assets.
The author recounts a three‑year career path from a fresh Android developer in Shanghai to a CTO, sharing interview struggles, project experiences, hiring strategies, agile management insights, and personal growth reflections that can guide aspiring software engineers and tech leaders.
This article explains the necessity of Android screen adaptation due to system and device fragmentation, defines screen size, resolution, and density concepts, introduces density‑independent units (dp, sp), and provides practical layout, component, and image resource adaptation techniques with code examples.
Learn step-by-step how to integrate custom icon fonts into a React Native app by downloading icons from Alibaba's Iconfont library, creating the assets/fonts directory, configuring iOS and Android projects, and using the fontFamily property to display vector icons across platforms.
This article analyzes the architectural redesign of BANFF, an internal sales mobile app, detailing the challenges of a flat, tightly‑coupled codebase and describing how modularization, technical abstraction, and page‑level refactoring transform it into a maintainable, extensible platform for diverse business roles.
This article describes how Baidu Map's client testing workflow was optimized by analyzing time‑consuming tasks, introducing device‑management and automation tools for Android and iOS, establishing a keyword‑driven framework, integrating continuous integration pipelines, and leveraging a user‑experience platform to achieve significant reductions in test execution time and higher test coverage.
This article explains Android's memory allocation and reclamation mechanisms, enumerates common memory problems such as leaks, OOM, and bitmap handling, and demonstrates a comprehensive optimization case study on the JOOX music app that reduced average memory consumption by over 40 MB.
This article examines the internal implementation of the Android Picasso image‑loading library, detailing its singleton initialization, request creation, builder pattern usage, caching mechanisms, delayed loading, and the workflow of actions, handlers, and thread execution to illustrate how images are fetched and displayed.
This article presents a low‑cost, high‑precision technique that leverages image‑recognition tools such as STF, Minicap, and Sikuli to automatically measure the first‑screen loading time of mobile web pages and Android APKs, detailing the required environment, setup steps, and execution workflow.
This tutorial demonstrates how to build a single, reusable SQLite library in Free Pascal using CodeTyphon, covering platform‑specific APIs, export conventions for Android, iOS, PC, and detailed compilation and usage examples across Android, iOS, macOS, Linux, and Windows.
This article explains the Android boot sequence, covering the bootloader's two stages, Linux kernel initialization, the Init process, the Zygote process that spawns application instances, and the role of ServiceManager and SystemServer in bringing the Android system to a ready state.
The open‑source Robust hot‑update system now includes an automated patch‑generation tool that scans original methods, rewrites field and method accesses to reflective calls, and creates hook classes to overcome ProGuard’s obfuscation, optimization, and inner‑class challenges, cutting patch creation time from a day to minutes.
Yoga, Facebook’s cross‑platform C‑based Flexbox layout engine with Java, C#, and Objective‑C bindings, lets developers define UI hierarchies using Flexbox properties, compile it via Buck or import a Gradle module, calculate node positions in Android, and manually apply them to Views, offering cross‑platform consistency but requiring extra integration effort.
This article provides a step‑by‑step tutorial on setting up the development environment, installing essential tools, and performing APK reverse engineering and security analysis on Android applications, covering JDK, SDK, NDK, Apktool, Dex2jar, JD‑GUI, IDA, WinHex, and Eclipse.
Atlas, Alibaba’s open‑source Android container framework, enables large‑scale team collaboration through componentization, dynamic deployment, and plug‑in isolation, offering parallel development, rapid iteration, and on‑device updates for apps targeting Android 4.x and above.
This article explains the end‑to‑end process of creating, releasing, and testing Android hotpatches—including release workflow, required files, implementation steps, comprehensive testing strategies, user‑transparent deployment, and common pitfalls—to ensure bug fixes reach users without disruption.
The article explains that each Unity scene runs inside an Android Activity by embedding a UnityPlayer FrameLayout, details how UnityPlayerActivity and GoogleUnityActivity load scenes, shows how to subclass these activities for custom integration, and outlines essential steps for creating reliable Unity‑Android plugins and handling assets.
The article recounts how a team of mostly iOS developers built the LightOxygen Android v1.0 app using React Native, detailing their version planning, feature set, React Native’s strengths and shortcomings, and future roadmap while sharing practical development insights.
When Android cannot use a specified nextFocusId, it gathers all focusable views via ViewGroup.addFocusables, converts their rectangles to the root’s coordinate space, and through FocusFinder.findNextFocus selects the nearest view in the requested direction, then requests focus, with key‑event handling prioritized before this automatic search.
Qunar React Native (QRN) is a customized cross‑platform mobile framework built on React Native that unifies iOS and Android UI, reduces app size, supports hot updates, offline bundles, custom IconFont, and has been deployed at massive scale within Qunar’s travel app.
Android M introduced a dynamic runtime permission model that separates normal and dangerous permissions, requiring apps like QQ Music to implement runtime checks, adapt startup and feature‑triggered requests, use a permission‑guard shell, and handle OEM‑specific fragmentation issues such as sensor, shortcut, and floating‑window permissions.
The 2016 Android & iOS Mobile App Quality Report shows a surge in device numbers, highlights higher crash rates for games versus apps, identifies common exceptions like NullPointerException, outlines manufacturer market shares, OS version distribution, and offers actionable insights for developers to improve stability across platforms.
After Android 5.0 introduced the NestedScrolling API, this article explains the underlying mechanism, key interfaces such as NestedScrollingChild and Parent, demonstrates a sample CollapsingLayout with NestedScrollView, and walks through the sequence of start, pre‑scroll, scroll, and stop callbacks with code examples.
This article traces the four stages of mobile terminal development, compares major smartphone operating platforms, and details Renren's practical experiences in unifying architecture, server design, and cross‑platform mobile development from JavaME browsers to iPhone and Android solutions.
Hardware acceleration in Android shifts intensive floating‑point UI work from the CPU to the GPU by building DisplayLists on the CPU and rasterizing them on the GPU, allowing parallel processing, selective redraw of unchanged elements, and significantly higher frame rates for animations and complex graphics.
The article introduces Google’s Espresso framework for Android UI automation, explains how to configure Gradle dependencies and the test runner, and guides developers through writing robust test cases by locating views, performing actions, and asserting states with onView().perform().check(), including a complete @Rule‑based example.
By exploiting the unprotected portion of Android’s APK Signature Scheme v2 signing block, the article introduces a fast, secure channel‑package generation technique—implemented in the open‑source Walle tool—that embeds custom IDs without re‑signing, enabling thousands of channels to be added in milliseconds per APK.
This article explains how to implement uniform fullscreen video playback on mobile browsers, covering iOS inline playback with the playsinline attribute, Android TBS engine tricks using x5-video-player-type and x5-video-player-fullscreen, handling events, centering videos, and provides code samples and compatibility tables.
The article describes a large‑scale Android architecture refactor that introduces interface‑driven programming, dependency injection, clear layer and role separation, and incremental migration across iterations to improve modularity, compile speed, maintainability, and horizontal scalability.
This article explains how Groovy parses Android-specific DSL in Gradle build files, covering DSL benefits, command chains, operator overloading, delegate mechanisms, and step‑by‑step execution of buildscript, repositories, dependencies, and tasks to help developers customize their Android build process.
This article provides a comprehensive guide to Android's RecyclerView, covering its core concepts, differences from ListView, standard implementation steps, custom adapters, item decorations, layout managers, animators, header/footer integration, empty views, drag-and-swipe handling, nested scrolling, and performance optimizations, with code examples and diagrams.
The article explains what Android core cracking is, its effects on app downgrade, overlay installation, and unsigned installs, discusses the optimal timing during Zygote initialization, outlines the modification of PackageManagerService methods, and notes that core cracking may fail after Android version updates.
This article explains how to measure and analyze Android app performance issues such as excessive battery drain, high network traffic, and UI jank by using tools like tcpdump, Wireshark, Android’s TCP statistics, and weak‑network simulators such as clumsy, providing step‑by‑step commands and configuration tips.
The article introduces Qunar’s Android cloud testing platform, explaining the challenges of device compatibility, detailing custom Monkey and automated test case features, describing device management, presenting usage data, outlining client‑server architecture, integration steps, and future expansion plans such as iOS support and high‑end device rental.
This article explains common Android performance problems such as high battery consumption, slow startup, memory leaks, and UI jank, and provides step‑by‑step methods using Android Studio, MAT, GPU rendering analysis, FPS Meter, and command‑line tools to locate and resolve these issues.
This article outlines mobile performance testing methods—including startup time, page response time, basic metrics, Monkey testing, and image‑recognition techniques—reviews third‑party tools, and introduces the in‑house ETest solution with its features and future development plans.
This article explains common Android performance problems such as battery drain, slow startup, and lag, and provides step‑by‑step instructions for measuring memory and CPU usage using adb commands, Android Studio tools, and the ActivityManager.MemoryInfo API.
The author shares a detailed recap of Google Developer Day, covering Android's new features and standardization, Web technologies like Progressive Web Apps, emerging AI and VR/AR demos, and overall insights on the direction Google is steering its developer ecosystem.
Hertz, Meituan Waimai’s mobile‑app performance monitoring framework, automatically detects development anomalies, generates test reports, and streams production metrics—such as FPS, CPU, memory, UI jank, page‑load time, and network traffic—using platform‑specific instrumentation and configurable modes to pinpoint and resolve performance bottlenecks across the app lifecycle.
Android applications often suffer from high battery drain, slow launches, and UI lag, so this article explains three practical methods—using ADB commands, screenrecord video analysis, and code instrumentation—to measure and analyze app startup time, with detailed steps, interpretation of timing metrics, and visual examples.
This talk explains how Qunar’s engineering team analyzed the performance bottlenecks of React Native’s ListView, compared it with native UITableView and Weex implementations, and proposed JavaScript‑based reuse logic and native bridge solutions to improve scrolling efficiency across iOS and Android.
This article introduces common Android app automation testing frameworks such as Instrumentation, UIAutomator, Robotium, Monkey, MonkeyRunner, MonkeyTalk, and Appium, explains their features and limitations, and provides detailed installation and usage instructions for Appium with Python examples.
This article explains what memory leaks are on Android, outlines their common sources, introduces various detection tools such as Lint, StrictMode, LeakCanary, Android Memory Monitor, MAT and adb commands, and provides practical strategies for locating and fixing leaks in mobile apps.
This article presents a detailed case study of the “Fish Fin” adaptive file‑transfer algorithm developed by Tencent’s Mobile Quality Center to dramatically improve image‑upload speed, success rate, and traffic efficiency on Android and iOS apps across varying mobile network conditions.
This article explains the fundamentals of the HTTPS protocol, details the SSL/TLS cryptographic components and handshake process, and provides a step‑by‑step guide for generating keystores, configuring Tomcat, modifying an Android client, and troubleshooting common issues during secure communication.
The article analyzes Android ART's method‑inlining optimizations, explains how they interfere with popular hot‑patch frameworks like Tinker, and describes the practical workarounds Tinker adopted to maintain patch compatibility while mitigating performance impacts.
After Facebook open‑sourced Redex, we explored its many optimizations and pitfalls, focusing on Interdex to reorder classes in the main dex, uncovering how class pre‑verification and hot‑patch instrumentation affect cold‑start performance, and sharing practical insights and remaining challenges for Android apps.
This article provides a comprehensive, source‑code‑driven guide to correctly using Android ImageView's src, background, transparency methods, foreground handling, adjustViewBounds, and scaleType attributes, helping developers avoid common pitfalls and achieve the desired visual effects.
The article clarifies that Android MVVM is an architectural pattern distinct from Google’s DataBinding tool, contrasts MVC and MVP shortcomings, outlines MVVM’s View, Model, and ViewModel layers with detailed responsibilities and sample RxJava/Retrofit code, and recommends using a global Messenger for decoupled ViewModel communication to achieve low‑coupling, testable, data‑driven UI development.
To shrink the QQ Music Android APK, the team replaced manual image compression with a multithreaded pngquant workflow that compresses PNGs at 90 % quality, integrates into the RDM build, cuts the res directory by 1.97 MB and the overall package by 2.22 MB, delivering faster, maintainable builds.
This article explains how WebP's lossless and lossy compression, including alpha and animation support, achieves significantly smaller image sizes than JPEG, PNG, and GIF, outlines its encoding pipeline, file structure, cross‑format comparisons, and current browser and Android implementation status.
This article shares Ctrip's experience of adopting React Native for its train ticket business, covering why RN was chosen, its current state, the Ctrip RN framework, practical implementation details, encountered pitfalls, and various optimization techniques to achieve near‑native performance and rapid iteration.
This article provides a comprehensive guide to Android app compilation, detailing the step‑by‑step build process, the use of Ant and Gradle tools, configuration of build.xml and build.gradle files, and essential settings such as obfuscation, signing, multidex, and code coverage to streamline CI pipelines.
This article compares Android's RecyclerView and ListView caching mechanisms, explains their multi‑level caches, shows how RecyclerView enables efficient partial refreshes, and concludes when each widget is appropriate based on performance and animation needs.
This article explains how to design a hybrid app's communication layer using JSBridge, outlines native‑H5 interaction patterns, presents bridge protocol implementations, discusses UI responsibilities, and describes offline H5 container architecture with local URL routing and update mechanisms.
The article details how Android music apps implement wired headset controls and lock‑screen metadata—using AudioManager and RemoteControlClient for pre‑5.0 devices and MediaSession/MediaSessionCompat for newer versions—while covering focus contention, custom lock‑screen handling, MIUI lyric integration, and other common pitfalls.
This article provides a comprehensive guide to Baidu's mobile SDKs—including Statistics, Map (location), and Voice—detailing their features, platform-specific integration steps for Android and iOS, and sample code snippets for developers to implement analytics, precise positioning, and speech recognition in their apps.
This article examines the caching mechanisms of Android's RecyclerView and ListView, comparing their hierarchical caches, view holder strategies, and partial refresh capabilities, and concludes when each component is preferable based on performance, animation support, and data update frequency.
ButterKnife is a compile‑time, annotation‑based dependency injection library for Android that uses JavaPoet‑generated helper classes to replace repetitive findViewById calls, offering faster development and runtime performance while adding a modest number of auxiliary classes and a one‑time reflection cost.
This article compares the MVC, MVP, and MVVM architectural patterns for Android mobile development, explains their differences, and provides step‑by‑step code examples for implementing MVP and MVVM, including model, view, presenter layers and data‑binding configuration.
This guide outlines essential Android security testing checkpoints, covering network communication risks, data storage protections, and packaging integrity measures to help developers identify and mitigate vulnerabilities before release.
This article chronicles WeChat's journey developing the Tinker hot‑patch framework, detailing the technical hurdles of native vs. Java approaches, performance optimizations, platform‑specific issues, and the rigorous testing that enabled a high‑availability solution for billions of Android devices.
This article outlines essential security checks for Android components—including Activity, WebView, BroadcastReceiver, Service, and ContentProvider—highlighting common vulnerabilities such as exported components, SSL handling, saved passwords, implicit intents, and unsafe broadcast APIs, and provides practical code examples and mitigation steps.
This article recounts WeChat’s two‑year journey developing the open‑source Tinker hot‑patch framework for Android, detailing the challenges of native vs Java approaches, performance‑critical DexDiff algorithms, platform‑specific issues on Dalvik, ART, and Android N, and the solutions that achieved a high‑availability, low‑overhead patch system.
This article explains Android's linker workflow for loading and linking native .so libraries, detailing the do_dlopen sequence, ELF parsing, memory mapping, soinfo allocation, relocation handling, and constructor calls, and concludes with a brief overview of common SO packing techniques.
This article explains the importance of unit testing in Android development, outlines why developers should invest time in it, and provides a step‑by‑step guide on writing effective Android unit tests using JUnit, Mockito, Dagger2, and Robolectric, along with practical tips, CI integration, and common pitfalls.
This article presents a comprehensive automated testing and proactive monitoring solution for Baidu Nuomi's O2O mobile component framework, detailing component‑level UI element identification, schema‑based entry shortcuts, wireless Android test apps, daily case execution, and a JavaScript‑driven monitoring engine that captures UI, request and exception anomalies across iOS and Android.
Android’s Data Binding framework links code and XML UI elements through compile‑time generated binding classes, supporting one‑ and two‑way bindings, reducing boiler‑plate, improving performance via a single view‑hierarchy traversal, offering expressive layout expressions, event binding, observable data models, dirty‑flag rebinds, and built‑in null safety.
The article examines Android power consumption by analyzing the BatteryStatsHelper source code, explains how CPU, wakelock, Wi‑Fi, mobile data and sensor usage contribute to energy drain, and demonstrates practical measurement techniques using adb commands, dumpsys batterystats, and third‑party tools such as PowerTutor and BetterBatteryStats.
The article outlines a comprehensive set of Android app performance metrics, device coverage, a non‑root sampling strategy using dumpsys commands, shell‑based data collection, and Python‑driven HTML reporting, providing practical guidance and reference implementations for mobile developers.
This article analyzes Meituan’s Robust hot‑patch solution, detailing its Instant Run‑inspired code injection, patch generation, production issues like method‑count limits and ProGuard inlining, performance impact, and real‑world deployment metrics, offering practical insights for Android developers.
This article explains how to quantify Android app frame rates, understand FPS concepts, calculate frame timing, and apply three practical methods—including GPU rendering profiling, adb gfxinfo, and SurfaceFlinger latency commands—to monitor and improve smoothness across multiple devices without rooting or API restrictions.
This article explains the concepts and practical usage of Dagger2 for compile‑time dependency injection in Android, illustrating why hard‑coded object creation is problematic, how constructor, setter, and interface injection solve these issues, and providing step‑by‑step code samples for modules, components, scopes, and qualifiers.
This article presents a detailed overview of mobile app performance testing, covering the importance of performance metrics for video applications, the prioritized dimensions such as smoothness, crash, memory and power consumption, and practical methods and tools for acquiring Android and iOS system metrics.
This article explains why Android apps encounter OutOfMemoryError, distinguishes memory leaks from heap overflow, and provides step‑by‑step guidance on using LeakCanary and the Eagle plugin for Eclipse to detect, compare, and fix memory leaks in Java applications.
This article explains Android performance testing challenges, details ANR causes and types, describes tools like TraceView and ANR‑WatchDog, and introduces VSync‑based smoothness metrics using Choreographer to detect frame skips and improve app responsiveness.
This article outlines comprehensive mobile performance testing practices for Baidu Video, covering background, key performance dimensions such as smoothness, crash, memory, power, CPU, and network, and detailing metric collection methods on Android and iOS using command‑line tools, Xcode Instruments, and third‑party utilities.
This article explains how to combine MVP architecture with RxJava in Android development, covering framework selection, step‑by‑step MVP construction, thread management using RxJava, and practical Q&A on testing, modularization, and memory‑leak prevention, providing a comprehensive guide for building decoupled, responsive mobile apps.
This article explains what ANR is, outlines its three trigger conditions, describes the system's ANR execution flow, compares FileObserver and WatchDog monitoring techniques, shows how to analyze ANR logs and main‑thread stack traces, and provides practical guidelines to avoid ANR in Android applications.
This article explains the concept of an EventBus as an observer‑pattern based communication mechanism for Android components, illustrates it with a newspaper subscription analogy, and provides step‑by‑step Java implementation details—including registration, unregistration, and posting of events using reflection—plus integration tips within an Activity lifecycle.
This guide explains how to use APKTool to decompile Android apps, inspect the AndroidManifest.xml for exposed components, and employ the Drozer framework to enumerate packages, assess component exposure, detect content provider leaks, SQL injection, file traversal, and service vulnerabilities.
The article examines typical coordinate‑system and accuracy problems encountered when implementing location and map features on iOS and Android, explains why they occur, and shares Ctrip's practical solutions including coordinate conversion, Wi‑Fi handling, and WebView‑based map rendering.
This article presents a detailed technical guide on optimizing Android applications across UI smoothness, memory management, network efficiency, power consumption, and code structure, illustrating practical tools, metrics, and real‑world case studies from Ctrip’s large‑scale mobile platform.
The article explains how Android developers can build dynamic user interfaces by programmatically creating and adding views, replace XML drawables with Drawable subclasses such as StateListDrawable, GradientDrawable, and LayerDrawable, and generate NinePatchChunk data at runtime to use server‑delivered .9.png images without pre‑processing.
This article explains the importance of stability testing for mobile apps, compares the limitations of the native Android Monkey tool with the system‑level SmartMonkey and a customizable module‑level approach, and provides detailed configuration, usage commands, and environment setup instructions for enhanced UI traversal testing.
LightListen adds flexible day/night and brand‑color switching by combining static XML styles and themes for basic modes with a dynamic configuration system—using shared‑preference color storage, view processors, and a traversal controller from the app‑theme‑engine library—to apply colors at runtime with minimal code duplication.
This article introduces Baidu's SmartMonkey, an Android system‑level stability testing tool built on Robotium, outlines its key features such as accurate page interaction, configurable critical paths, performance data collection, and provides step‑by‑step instructions for project setup, configuration, test execution, and report analysis.
Android app internationalization involves extracting hard‑coded strings into language‑specific strings.xml files, using Lint and regex to locate text, annotating resources, formatting placeholders, exporting for translation, updating the Resources configuration at runtime, handling UI refresh via onConfigurationChanged, recreate or activity restart, and adjusting layouts for length, dimensions, and caps to ensure a seamless multilingual experience.
