This article explains why Android apps suffer noticeable delays on cold start, breaks down the launch lifecycle, and provides practical optimizations—including reducing work in lifecycle callbacks, avoiding unnecessary delays, customizing window backgrounds, and using profiling tools—to dramatically cut startup time.
This article provides a comprehensive overview of Kotlin, covering its basic syntax, key language features such as static typing, type inference, functional and object‑oriented support, its design philosophy of practicality, conciseness and safety, seamless Java interoperability, and its applications in server‑side and Android development together with tooling and compilation details.
This article presents a comprehensive technical solution for JD.com's mobile product detail page, describing the challenges of static layouts, the concept of floor-based dynamic composition, server‑driven configuration, implementation steps, and performance optimizations using RecyclerView and bitmap substitution to ensure a flexible, low‑latency user experience.
This article explains Android permission fundamentals, how to perform runtime permission checks across different SDK levels, compatibility strategies for older devices, and practical methods to jump directly to the app's permission management screen on various OEM ROMs.
This article explains the reasons for using LLVM to obfuscate Android applications, describes various LLVM-based obfuscation techniques such as instruction substitution, control‑flow flattening, bogus control flow, and custom passes, and illustrates their effects with diagrams.
The article defines dynamic image formats, traces their history from GIF to WebP, compares GIF, APNG and WebP features and Android decoding performance, showing WebP offers smaller files and faster loading at higher CPU cost, while GIF remains most compatible and CPU‑efficient.
The article introduces Wang Yaobo’s presentation on Ctrip’s "real‑time handheld testing" technology, explaining how to monitor key performance metrics, capture crashes and stalls in authentic environments, and pinpoint problematic code lines to improve Android app quality.
This article provides a comprehensive overview of Android O's major updates—including Fluid Experiences like notification channels, picture‑in‑picture, adaptive icons, autofill, and media enhancements—along with behavior and security changes, new APIs, and practical code examples for developers.
This article introduces SmartMonkey, a custom Android testing solution that overcomes the randomness and inefficiency of the built‑in Monkey tool by using UIAutomator to parse UI hierarchies, select meaningful nodes, and execute controlled actions for more effective stability and functional testing.
This tutorial explains how to build and integrate OpenSSL 1.1.0e for modern Android, iOS, and Linux environments, providing shell scripts for each platform, detailed configuration steps, and examples of using the resulting static libraries in C, JNI, and Java code.
The article describes how to remotely debug Android apps by creating a custom JDWP socket channel that bypasses Android 7.0’s library restrictions using a fake dlsym ELF parser, enabling developers to retrieve runtime state from production builds without prior instrumentation or user cooperation.
This article explores how applying a Lego‑like page‑structuring approach to Android MVP can improve decoupling, reduce method count, and enhance maintainability, while comparing its benefits and drawbacks against traditional MVP implementations.
The article explains how upgrading the Android NDK introduces threading pitfalls such as ANR and FindClass failures, and provides step‑by‑step solutions using main‑thread class lookup, global references, and thread attachment to safely execute JNI calls in background threads.
Android O (8.0) adds fluid‑experience features such as notification channels and dots, picture‑in‑picture, adaptive icons, autofill, downloadable fonts, pinned shortcuts, TextView auto‑sizing and media enhancements, while Vitals improve battery, security and stability, and it introduces background execution limits, stricter permissions, new WebView and UI APIs, unified margins, animation set improvements, and overlay‑window changes.
This article provides a detailed technical walkthrough of how the Xposed framework replaces the Android Zygote process, initializes its runtime, registers services, and hooks methods by examining the main, initialize, startAll, and onVmCreated functions along with installation steps.
This article chronicles the evolution of WeChat's Android architecture from a simple layered design through multi‑process and modular restructurings, explains why a major refactor was needed, and details the new communication, module, and code‑boundary strategies that enable faster development, better isolation, and a lightweight WeChat nano demo.
Didi’s newly open‑source VirtualAPK framework lets Android apps deliver new features, hot‑fixes, and experimental functionality instantly through modular plugins, offering full component support, minimal intrusion, easy host‑resource access, and broad device compatibility—overcoming the limitations of existing plugin solutions for rapid, reliable business updates.
This article examines Kotlin’s rise after Google I/O 2017, its multi‑platform compilation capabilities, key language features such as immutability, reduced boilerplate, null‑safety, and seamless Java interoperability, while offering practical insights for Android and cross‑platform mobile developers.
This article explains how WCDB for Android simplifies encryption with SQLiteCipherSpec, enables seamless data migration, provides a custom FTS3/4 tokenizer with dynamic ICU loading, and offers log redirection and performance monitoring tools, plus an optimized cursor implementation for high‑performance mobile apps.
This article explains various Android network traffic measurement techniques, including reading Linux proc files, using the TrafficStats and NetworkStatsManager APIs, and built‑in monitoring tools, while discussing their advantages, limitations, and practical code examples for accurate per‑app data usage analysis.
This article explains how to render rich, styled text in an Android OCS player by evaluating open‑source libraries, selecting HtmlSpanner, and detailing HTML tag support, CSS parsing, multi‑font handling, custom font loading, common pitfalls, and future improvement ideas.
On June 17 in Hangzhou, Alibaba partnered with Huawei and the Android Green Alliance to host an Android developer salon where experts presented the Atlas containerization framework, discussed Android O features, Kotlin adoption, AR/VR and AI impacts, and explored future trends and green, secure mobile app standards.
This article explains how to implement a reliable Android music app by leveraging MediaSession for UI‑service synchronization, handling background playback, MediaButton events, AudioFocus, Wi‑Fi and WakeLocks, custom notifications, and compatibility across Android versions.
The article reviews Google I/O 2017, highlighting Android's shift to Kotlin, the introduction of Android O features, the launch of AI‑driven services such as Google Lens, Assistant, and Home, and the broader move from a mobile‑first to an AI‑first strategy.
This article reviews the evolution of Android app architecture over several years, describing the shortcomings of a simple two‑layer design, the adoption of RxJava and MVP patterns, and the resulting benefits and remaining challenges for building maintainable mobile applications.
This article introduces Kotlin fundamentals for developers, covering variable declarations, control flow statements such as if, when, and loops, smart type inference, null-safety, function definitions with default parameters, varargs, extension functions, and provides practical code examples to help newcomers quickly adopt Kotlin.
This article chronicles the development of WCDB, WeChat’s open‑source mobile database, detailing its early challenges, performance bottlenecks, security risks, concurrency improvements, cross‑platform collaboration, and future roadmap for a more reliable and efficient data layer on iOS and Android.
In this interview, senior Android developer Xu Yisheng shares his career journey from system‑level work at TCL to leading component development at Hujiang, discusses his books, learning methods, open‑source plans, and advice for aspiring mobile developers.
This article provides a detailed analysis of the Xposed framework on Android, explaining its purpose, how it integrates with the Zygote process, and step‑by‑step walkthrough of the Hook workflow, including key native methods, ArtMethod manipulation, and example code for method interception.
This article explains three Android CPU performance testing techniques—using adb dumpsys cpuinfo, reading /proc/pid/stat, and employing the top command—detailing their procedures, advantages, limitations, and how to aggregate per‑process data for accurate app‑level metrics.
This article chronicles Alibaba's multi‑year journey in Android hot‑fix technology, compares early solutions like Dexposed, AndFix and others, and details Sophix's non‑intrusive design that unifies code, resource and native library patching while maintaining compatibility, security and ease of use across Android versions.
This tutorial introduces Kotlin, explains its advantages over Java, guides you through setting up IntelliJ IDEA or Android Studio with the Kotlin plugin, and walks you through creating and running both a simple Hello Kotlin program and an object‑oriented example, while covering coding style recommendations.
This article chronicles the development of WCDB, Tencent WeChat's open‑source mobile database, detailing its early platform challenges, performance and security improvements, cross‑platform collaboration, and future plans to enhance usability, speed, and reliability.
This article compares Facebook's open‑source static analyzer Infer with 360's Fireline, focusing on resource‑leak detection for Android, presenting test methodology, detailed results across 30 leak scenarios, and highlighting Fireline's higher detection rate and lower false‑positive ratio.
This tutorial demonstrates how to build an Android login interface using Kotlin, covering class inheritance, nullable variable declarations, lambda listeners, network requests, and an extension function that adds a toast method to all Activity subclasses, with full source code examples.
This article provides Android developers with practical guidance on using Kotlin instead of Java, covering basic syntax, data classes, singletons, activity navigation, Retrofit with OkHttp, and RxJava to streamline development and improve productivity.
Google’s 2017 I/O announcement made Kotlin a first‑class Android language, and this article explores how Kotlin’s Java interoperability, lambda support, coroutines, and null‑safety can reshape Android development, while also critiquing legacy utility classes and encouraging developers to adopt modern Kotlin features.
This article explains how Dagger 2 structures dependency injection for Android apps using Modules, Components, and Subcomponents, illustrating their roles with diagrams, comparing them to manual injection, and showing how they clarify code dependencies while keeping runtime overhead minimal.
This article presents a detailed analysis of the evolution from MVC to MVP in Android hotel‑business development, illustrates common pitfalls such as bloated controllers and context loss, introduces Ctrip's extended MVCPI pattern with weakly‑typed IView, Presenter and Interactor components, and provides concrete code examples for each architecture.
This article shares the most frequent Kotlin-related issues encountered in Android projects—including IDE conversion bugs, DexGuard obfuscation crashes, debugging difficulties, missing ternary operators, and other language quirks—along with practical solutions and code examples to help developers avoid them.
The article introduces Kotlin, explains why it gained sudden popularity after Google’s I/O announcement, shares the author’s experience of adopting Kotlin in large Android projects, discusses its impact on bug rates and developer productivity, and encourages developers to explore the language responsibly.
The 2017 Google I/O recap highlights the company's shift toward artificial intelligence, detailing AI initiatives, Android Oreo updates, new hardware like Google Lens and Assistant, and the broader integration of AI across products and developer tools such as TensorFlow and Cloud TPU.
This article explores Kotlin's rise as a first‑class Android language, highlighting its concise syntax, null‑safety, extension functions, functional programming features, seamless Java interoperability, performance parity, and practical tips for teams transitioning from Java to Kotlin.
This article introduces Kotlin as a first‑class language for Android, explains why developers should adopt it, and provides a step‑by‑step guide to setting up Android Studio for Kotlin development, including plugin installation, project conversion, and configuration details.
This article examines the evolution of Android UI architecture from traditional MVC to MVP and introduces the MVCPI extension, discussing practical implementation details, performance considerations, common pitfalls, and solutions such as interface-based views, presenter responsibilities, and interaction models to improve code maintainability and scalability.
This article reviews a year of development on Tencent's Tinker hot‑fix framework, detailing ecosystem growth, major technical pitfalls on Dalvik, ART, OEM integrations, and the practical solutions that emerged to keep Android apps stable and updatable.
The article explains Android 6.0’s audio volume architecture, detailing how streams, devices, and per‑stream volume indices are defined, cached, persisted, and modified via AudioManager or AudioTrack/MediaPlayer, and how these changes travel through AudioService, AudioPolicy, and AudioFlinger to the hardware.
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.
