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.
The article presents an in‑depth technical overview of Qunar's Spider framework for Android modular development, describing its component model, architecture, development workflow, performance benefits, comparison with other dynamic‑loading solutions, and step‑by‑step guidance for building and releasing Spider‑based apps.
This article presents a detailed overview of mobile app performance optimization, covering UI responsiveness, memory management, network efficiency, power consumption, and code improvements, with practical analysis methods, tools, and case studies from major companies such as Ctrip and Alibaba to help developers enhance Android applications.
This article explains the fundamentals of Bézier curves, demonstrates how to simulate quadratic and cubic Bézier paths on Android using the provided APIs, and explores practical applications such as smooth drawing, wave effects, and path animations with code examples and visual references.
This article introduces the Spider framework used at Qunar for Android modular development, explaining its architecture, component model, development and release workflow, performance benefits, dynamic loading features, and provides a quick‑start guide with examples and resources.
Android Content Providers are a core component that expose a uniform, permission‑controlled CRUD interface via content:// URIs, require manifest declaration, load lazily, support custom implementations, multi‑process instances, shared‑memory cursor transfers, observer notifications, and handle large‑data limits through batching.
This article explains the fundamental role of Android Activity as the primary UI component, its interaction with layouts and context, how it saves state, handles configuration changes, switches with services, and details its complete, visible, and foreground lifecycles as well as the various process priority levels in Android.
This article explains how to apply for WeChat Pay, obtain required credentials, and integrate the payment flow—including unified order, signed parameter generation, client SDK invocation, and asynchronous result handling—on both Android and iOS platforms using PHP examples.
Android's fragmented versions and market‑specific policies make bug fixes and version upgrades painfully slow, but by treating the app as a loader and delivering patch files that replace the Application class, dex files, resources, and native libraries, developers can achieve near‑instant, user‑transparent updates without disrupting the normal release flow.
This article explains how to choose an Android framework, build a layered MVP architecture, and use RxJava to move network requests off the main thread, providing clear code examples and practical tips for scalable, testable mobile apps.
This article presents a comprehensive, evolving mobile performance evaluation framework for O2O applications, detailing assessment parameters, multi‑stage automation approaches, uiautomator enhancements, and key technical optimizations to enable timely, extensible, and accurate performance testing of competitive mobile products.
This article explains the compatibility challenges of Android custom notifications, compares simple fixed‑background and adaptive color‑matching approaches, and presents an improved method that extracts notification title colors to dynamically select suitable layouts across diverse ROMs and UI themes.
The article details the practical challenges, RTL rendering issues, Android version compatibility, string direction bugs, cultural content restrictions, numeral formatting, and testing procedures encountered while adding Arabic language support to a mobile application.
This article provides a detailed walkthrough of a self‑developed Android social application, covering its functional modules, mobile architecture layers (framework, threading, caching, networking, implementation), server‑side design, database choices, third‑party libraries, and performance optimizations.
This article explains Android Vector Drawable, covering its advantages over bitmap drawables, the SVG‑based syntax, how to obtain and create vectors, compatibility across Android versions, static and animated usage in UI components, performance considerations, and relevant code examples.
This guide walks you through configuring Jenkins on a CentOS 6.3 server to automatically compile Android projects from a GitLab repository, covering environment preparation, Jenkins installation, job creation, Gradle integration, and troubleshooting common issues such as SDK updates, permission errors, and memory limits.
This article explains various Android memory testing techniques—including ActivityManager.MemoryInfo, adb commands, procrank, and DDMS/Mat tools—while describing usage intensity scenarios and how to interpret memory metrics to improve app stability and user experience.
Developers can create a custom Android lock screen by starting a foreground service that registers a dynamic SCREEN_OFF broadcast, launching a lock‑screen activity with keyguard‑dismiss and immersive window flags, handling swipe‑to‑unlock gestures, making navigation bars transparent, and integrating fingerprint authentication while respecting system security constraints.
This article explains why a custom lock screen is useful, describes the core principles of implementing one on Android, and provides step‑by‑step code for broadcast registration, activity configuration, key event blocking, swipe‑to‑unlock logic, immersive and translucent UI flags, and fingerprint integration.
During a Dev Club session, Tencent engineers shared a comprehensive review of their React Native adoption, covering project history, architecture, version management, performance optimization, crash analysis, and practical tips for mobile developers seeking to balance native quality with cross‑platform efficiency.
This article explains how to use Android Studio’s Allocation Tracker, automate its start/stop via code using the ddmlib library, and directly access Dalvik’s internal allocation records to retrieve object size, type, and stack information with minimal performance impact, while discussing limitations and compatibility concerns.
This report analyzes client‑side traffic consumption caused by app icon downloads, proposes a DPI‑based icon size selection algorithm, evaluates its impact across various device resolutions, and presents data‑driven conclusions on traffic savings and user experience for Android applications.
The article outlines essential choices such as protocol and server selection, XMPP improvements, mobile network and power optimizations, client‑side handling, and scalability techniques required to develop a reliable, high‑performance instant messaging feature for Android and iOS apps.
This article reviews the evolution of Android hot‑patch technologies, compares major solutions such as Dexposed, AndFix, Qzone, and WeChat’s own Tinker, and explains when and how to apply hot patches for lightweight updates, remote debugging, and data‑driven testing.
After transitioning from JavaEE to Android development, the author shares practical insights on designing robust mobile app architecture, covering maintainability, extensibility, security, onboarding ease, documentation, packaging, and the trade‑offs between MVC and MVP, while offering guidance on framework selection and effective encapsulation.
This article shares practical insights on Android app architecture, covering maintainability, extensibility, security, onboarding friendliness, documentation, package organization, MVC vs MVP patterns, and guidelines for selecting and encapsulating frameworks to build robust mobile applications.
This article explains the complete Android phone boot sequence—from power‑on, through the BIOS‑like bootloader, Linux kernel initialization, init and Zygote processes, to the launch of the first app and the desktop UI—in clear, step‑by‑step detail.
This article explains how to use the CodeTyphon IDE and Free Pascal Compiler to create reusable cross‑platform libraries, covering environment setup, compilation commands for Android, iOS devices and simulators, and a complete Pascal example with JNI bindings.
This guide walks you through what Weex is, where to obtain it, how to set up the Android environment and weex‑toolkit, and provides a step‑by‑step example—including template, style, and script code—to run a simple Hello World app on Android, while noting common pitfalls and solutions.
The article presents an Android incremental‑update solution that uses bsdiff‑generated binary patches to replace full APK downloads, embeds channel identifiers in the ZIP comment field to avoid per‑channel APK duplication, and details server‑side patch creation, client‑side channel stripping, patch merging, and verification to reduce bandwidth and simplify multi‑channel distribution.
Even high‑end Android devices can feel sluggish due to overdraw, where the GPU renders the same pixel multiple times; this article explains Android’s rendering pipeline, how to detect excessive drawing, and practical techniques—such as simplifying layouts, using transparency, and merging views—to cut draw calls and achieve smooth 60 FPS performance.
Godeyes is a cross‑platform static analysis tool that scans Android applications for crash‑related issues such as API incompatibilities, OOM risks, and uncaught exceptions, offering Eclipse, Android Studio, and Jenkins integrations along with customizable rules and detailed HTML reports.
This comprehensive guide walks Android developers through Retrofit’s fundamentals, usage patterns, URL configuration, parameter handling, custom converters, call adapters, and advanced techniques like file uploads, mock servers, and RxJava integration, providing code examples and deep insights to master network requests efficiently.
To guarantee a single persistent main Activity while allowing sub‑Activities and third‑party navigation, the article proposes routing all external and internal launches through a dedicated DispatcherActivity that uses FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TOP, a static weak reference, and onNewIntent handling, avoiding singleTask/instance modes.
This article details the step‑by‑step evolution of the English Fluency Android app’s architecture, covering its early broadcast‑based design, the adoption of a plugin‑based modular core, multi‑process integration, auxiliary systems such as asynchronous loading, event bus, monitoring, and support components for file storage, DNS protection, image loading, and downloading.
This article continues a previous guide by demonstrating how to define a complex custom PMD rule that flags Android log statements exposing sensitive data such as device identifiers, process IDs, class names, and file paths, illustrating rule design, AST analysis, example code, and verification steps.
The article walks through Android Gradle’s three‑phase build cycle, explains how VariantManager, TaskManager and AndroidBuilder create and configure tasks, then dives into the class‑to‑dex conversion process, detailing common multi‑dex limits, troubleshooting steps, and custom Gradle tasks that shrink keep lists and analyze dependencies to avoid build failures.
SonarQube, an open‑source code quality platform, offers extensive static analysis for Android (Java) projects through plugins that assess complexity, duplication, test coverage, coding standards, comments, potential bugs, and architectural design, and integrates with IDEs and CI tools such as Jenkins to visualize and reduce technical debt.
This article explains the principles and practical steps for implementing dynamic class loading and hot‑fixes in Android by manipulating DexClassLoader, PathClassLoader, and bytecode, illustrated with the Qzone hot‑fix solution and open‑source Nuwa and HotFix projects.
This article explains how Android hybrid apps enable JavaScript‑Java communication, compares four JS‑to‑Java methods, shows the single Java‑to‑JS approach, and provides a detailed walkthrough of the open‑source JsBridge library with code samples and workflow diagrams.
This article explains the problems of manual mobile web page load testing, introduces STF and its Minicap screenshot tool, details their features, installation prerequisites, step‑by‑step setup commands, and demonstrates how to run and access STF for automated, low‑latency testing.
This article compares Java, Groovy, Scala, and Kotlin for Android development by examining minimal dependencies, code snippets for view lookup, click listeners, callbacks, community support, and preliminary metrics such as line count and compile speed, concluding that further analysis is needed.
This article explains how to perform function-level performance testing on Android applications by leveraging Hook frameworks to monitor each method’s execution time and call count, detailing function selection, class categorization, monitoring levels, data collection, result analysis, and practical implementation considerations.
EventBus 3 provides a lightweight publish/subscribe framework for Android that simplifies inter‑module communication by allowing any object to be posted and received via @Subscribe methods, with optional index acceleration for faster registration, customizable thread modes, and guidance on setup, ProGuard rules, pitfalls, and alternatives.
The article explains how to turn a traditional Android singleton into a cross‑process object by having the singleton implement an AIDL interface, exposing it through a bound Service, and using Parcelable‑based Binder serialization so multiple processes share the same instance while handling IPC, threading, and data‑type constraints.
This tutorial explains how to compile the Swift standard library for Android armv7, build required dependencies, create a simple Swift program, deploy the binaries via ADB, and successfully run a "Hello, Android" application on an Android device.
This article shares practical experiences and best practices for Android unit testing, covering why testing matters, simple test structures, mocking with Mockito, dependency injection via Dagger2, using Robolectric, CI integration, common pitfalls, and a detailed checkout flow example.
This article explains how most Android code is driven by event callbacks, examines single‑event and multi‑event implementations, discusses the pitfalls of bloated callbacks, and offers practical strategies to structure and simplify callback‑heavy code for clearer, more maintainable apps.
After years of iOS development, the author switched to Android, highlighting the limitations of iOS web support, the rise of Service Workers and Progressive Web Apps on Android, and how these open‑web technologies offer faster, cross‑platform experiences without App Store constraints.
This article explains the motivations behind adopting a hybrid framework for Android apps, outlines the overall architecture, details the WebView loading flow, jump protocol, resource interception, asynchronous image handling, cache version management, and interaction mechanisms, providing practical code examples.
This article explains how to determine whether a client device supports IPv4‑only, IPv6‑only, or dual‑stack networking on iOS and Android, covering gateway detection, DNS analysis, socket‑connect tests, and practical code samples for reliable IP‑stack identification.
During the second day of Microsoft Build 2016, Xamarin was showcased as a free, open‑source solution that lets Visual Studio users develop, test, and monitor Android and iOS applications on Windows, including an iOS simulator previously limited to macOS.
This article explains how the Flux data‑driven architecture, originally created for Facebook's web client, can be adapted for Android applications, describing its four core modules, their interactions, and a practical ToDoList example with code snippets.
Android Lint, Google’s static analysis tool, scans Android code for potential bugs and style violations, enabling developers to fix problems early, and Meituan enforces its use in the development pipeline so that any Lint-detected issues block merges into the main branch, ensuring higher code quality.
This article compiles essential Android interview knowledge, covering MVC, MVP, and MVVM patterns, Volley disk cache mechanics and optimization, bitmap memory handling, heartbeat packet types, HashMap internals, and the differences among atomic, volatile, and synchronized constructs, while highlighting relevant design patterns.
This article explains the purpose of architectural design in Android apps and provides a detailed comparison of MVC, MVP, and MVVM patterns, including their structures, advantages, drawbacks, code examples, as well as an introduction to AOP and practical development tips.
This article details a step‑by‑step approach for transforming a modern Android phone application into a tablet‑optimized version within three months, covering UI redesign, activity‑to‑fragment conversion, multi‑process handling, task management, and practical code snippets for a robust Pad‑ification architecture.
This article summarizes a March 10 technical session on componentizing iOS and Android applications, describing the challenges of monolithic codebases, the benefits of modular architecture, communication patterns, lifecycle management, version control, CI integration, and practical lessons learned.
This article provides a comprehensive source‑code analysis of React Native's Java↔JavaScript communication mechanism on Android, detailing module registration, the Java‑to‑JS and JS‑to‑Java call flows, and the underlying native bridge implementation.
The article introduces FindBugs, an open‑source Java static analysis tool, explains how it inspects Android bytecode to detect bugs such as null pointers, multithreading issues, and performance problems, and describes its integration with IDEs, command‑line builds, and its severity ranking system.
This article breaks down the true cost of developing a native mobile app in China, covering developer salaries, team composition, timeline, low‑budget alternatives, template platforms, and when a company should choose a native app versus a Web‑App solution.
Android Lint is a static code analysis tool for Android that detects potential defects and optimization opportunities across correctness, security, performance, usability, accessibility, and internationalization, offering command‑line and IDE integration, customizable rules, and detailed HTML reports to improve code quality.
This article investigates how long‑term use of Android devices leads to storage fragmentation and write amplification, explains the underlying NAND flash mechanisms, and evaluates TRIM‑based solutions such as discard and fstrim for restoring I/O performance.
This article examines how the Android team built WeChat’s 2016 Red Envelope Photo feature, covering its modular architecture, tight development timeline, performance optimizations, security measures, and controllable flow to deliver a smooth user experience.
Facebook tackled Android performance monitoring by replacing manual instrumentation with a rule‑based bytecode rewriter that automatically injects tracing markers, minimizes overhead, and captures cross‑thread activity, offering a scalable solution for real‑world telemetry collection.
This article explains how Ctrip’s Android app adopted a plugin‑based, dynamic‑loading framework to overcome method‑limit, improve build speed, enable hot‑deployment, and support modular A/B testing, detailing the underlying principles, compilation changes, runtime resource and class loading, and the trade‑offs involved.
At AnDevCon, senior engineers from Twitter, Amazon, Cyanogen, Square, Eventbrite and others shared practical strategies for managing large Android teams, implementing effective testing pipelines, leveraging A/B experiments, designing for testability, handling embedded testing, contributing to open‑source, and using analytics to drive product decisions.
Google announced a new Android‑integrated virtual reality headset, a successor to Cardboard, aiming to challenge Oculus and expand VR adoption by leveraging smartphones, which could reshape the VR hardware market and shift competition toward content creation.
This article explains Android's DisplayMetrics density values, shows how to calculate a Bitmap's runtime memory footprint using getByteCount, explores the impact of screen density, pixel format, and scaling, and provides practical techniques such as inSampleSize, matrix scaling, and pixel format selection to minimize memory consumption.
This article explains how to configure Android Studio for Robotium testing, create and run test cases, and integrate automated tests into a Gradle‑based continuous integration pipeline using Jenkins.
An in‑depth look at Alipay Wallet’s mobile client monitoring system, detailing strategies for traffic and power optimization, comprehensive diagnostics, dynamic upgrades, AOP‑based instrumentation, and practical techniques for reducing data usage and battery drain on resource‑constrained Android devices.
An ex‑WeChat engineer shares practical strategies to accelerate Android development, covering RxJava for reactive streams, MVP/MVVM architecture, REST client generation, image‑loader choices, quality monitoring tools, and workflow best practices that can help startups build high‑performance apps efficiently.
The article presents a cloud‑plugin based method for mobile app testing that dynamically injects offline test capabilities into production devices, enabling comprehensive user‑interaction logging, low‑impact issue detection, and rapid debugging of performance problems such as frame‑rate drops.
This article dissects Qingting FM’s Android app, revealing how it spawns multiple background services, launches invisible activities, and uses hidden WebViews to fake daily active users and ad impressions, while providing step‑by‑step reverse‑engineering instructions for developers.
This tutorial explains how to create an Android AccessibilityService plugin that automatically detects and clicks all WeChat red packets, detailing its stage‑based logic, screen‑content detection, node handling, queue management, and provides complete source code for educational use.
This tutorial walks you through setting up a secure virtual Android environment on Kali Linux, installing required libraries, the Android SDK, creating AVDs, configuring the Smartphone‑Pentest‑Framework, and launching the framework to demonstrate mobile phone hacking techniques.
This guide walks you through creating a safe Android pentesting environment on Kali Linux, covering library installation, Android SDK setup, virtual device creation, framework deployment, and necessary service configuration to safely test smartphone vulnerabilities.
This article outlines comprehensive Android memory optimization strategies, covering leak detection with LeakCanary, system‑level hacks, bitmap handling, runtime monitoring, multi‑process usage, and GC tuning, providing practical code snippets and tools to reduce RAM usage, prevent OOM crashes, and improve app performance.
This article explains what ANR is, why it harms user experience, typical scenarios that cause it, how to locate ANR issues via logs, and provides step‑by‑step guidance for integrating an ANR detection tool into Android applications such as Baidu Browser.
The article presents a detailed case study of an Android WebView memory‑leak bug that gradually slows page opening, explains how DDMS and MAT were used to pinpoint the leaking DynamicBgDrawable objects, and describes the fix of converting a strong view reference to a weak reference to eliminate the leak.
This article walks through the evolution from Ant to Maven to Gradle for Android projects, explains Gradle's project structure, key concepts like repositories, source sets, properties, tasks, shows how to publish artifacts, create and use plugins, and offers tips to speed up Gradle builds.
This article explains why INSTALL_FAILED_DEXOPT occurs on Android versions below 3.0, details Google’s official multidex solution, and presents a custom automatic dex‑splitting and dynamic loading approach that overcomes method‑count and LinearAlloc limits while maintaining app performance.
Security researchers discovered a wormhole‑style flaw in the popular 360 Browser for Android that allows remote code execution through a custom HTTP service, affecting both rooted and non‑rooted devices, and a patch (version 6.9.9.71) was released on November 23 to mitigate the issue.
This article compares three popular Android hot‑patch mechanisms—Dexposed, AndFix, and the ClassLoader‑based approach—detailing their underlying principles, implementation details, code examples, and evaluating their compatibility, performance, and ease of use to help developers choose the most suitable solution.
The article presents a detailed case study of an Android WebView memory leak that causes progressively slower page loads, explains how DDMS and MAT were used to pinpoint the leak in DynamicBgDrawable via a WeakHashMap reference cycle, and proposes converting the view reference to a weak reference to resolve the issue.
This tutorial explains how to build hybrid mobile apps by embedding web pages in native iOS UIWebView and Android WebView components, covering resource loading, JavaScript‑native communication, and bidirectional interaction techniques for cross‑platform development.
This guide explains how to apply clean architecture principles to Android development by separating concerns into presentation, domain, and data layers, ensuring framework, UI, and database independence, and providing testing strategies and error‑handling techniques for a maintainable app.
This article explains what Android ANR (Application Not Responding) is, outlines typical scenarios that cause it, describes how to locate ANR issues via logs and traces, and details the integration and usage of an ANR detection tool to automatically capture diagnostic data for debugging.
The article reflects on the evolving role of a software architect through personal experiences at Tieto, Sony, and a bank, highlighting responsibilities, team organization, project leadership, and the broader mindset that makes anyone a de‑facto architect in both technology and life.
This guide explains practical techniques for spotting basic memory leaks, using the MAT tool to analyze heap dumps, comparing hprof files, and implementing daily leak monitoring in Android apps through AspectJ instrumentation, MLD utilities, and UIAutomator automation.
This article reviews the five most popular open‑source mobile automation frameworks—Calabash, Appium, Robotium, Frank, and UIAutomator—detailing their key features, advantages, and drawbacks to help developers choose the right tool for iOS and Android testing.
This article outlines seven practical strategies—including monitoring, network upgrades, caching, task grading, lazy loading, page structure refinement, and image download optimization—to significantly improve the launch speed, home page responsiveness, and cart performance of the Mobile Taobao application.
The interview details how Alibaba's mobile Taobao app was re‑architected and heavily optimized—through network protocol tweaks, APK size reduction, power and data monitoring, extensive device compatibility testing, HTML5 rendering improvements, and game‑like marketing features—to sustain over 70% mobile sales during the massive Double 11 shopping festival.
A user received a suspicious SMS with a malicious app link, prompting an analyst to download, decompile, and dissect the Android malware, revealing hidden Device Admin permissions, obfuscated code, DES-encrypted credentials, and the attacker’s email address, ultimately exposing how the trojan steals personal data.
This article explains the motivations, design principles, compilation and runtime techniques of Ctrip's Android plugin‑based architecture and dynamic loading framework, detailing how it solves method‑count limits, improves build speed, enables hot‑deployment, and outlines the associated trade‑offs.
