This article outlines the motivation, tool comparison, and detailed step‑by‑step process for implementing static code scanning across Android and iOS codebases, emphasizing the selection of Infer and the integration of scanning results into CI pipelines and issue‑tracking workflows.
This article provides a step‑by‑step tutorial for creating, configuring, and debugging JDReact projects—including project initialization, npm/yarn setup, styling conventions, routing, network requests, animation handling, scroll‑view tricks, H5 conversion issues, and deployment tips—while highlighting frequent Windows compatibility problems and practical solutions.
This article describes Qunar's approach to quantifying, automatically detecting, and optimizing performance issues in React Native mobile apps by defining measurable metrics, real‑time data sampling, automated analysis rules, and visual feedback to enable proactive APM during development and testing.
This article explores Flutter's memory management, detailing the Dart runtime's generational GC, comparing Image widget memory usage across Android versions, and evaluating the impact of reusing or not reusing FlutterView on Java and native memory consumption, with practical test results and optimization tips.
The 2018 Qunar Technology Carnival QClient session on May 19 concluded with thanks to judges, hosts, volunteers, and a series of technical talks covering Flutter, ReactNative performance monitoring, instant‑messaging cloud, anti‑crawling platform, YApi API management, Android custom builds, and QRMaps indoor mapping, followed by lively audience interaction and a group photo.
This article provides an in‑depth technical overview of Flutter, covering its Dart‑based architecture, layered widget system, event handling, animation, navigation, plugin ecosystem, performance and APK size comparisons with WebView‑based frameworks, React Native, and native Android/iOS development.
This article explains how Android's TextView renders text, detailing its coordinate system, layout classes, span types, HTML conversion, and practical implementations such as custom ReplacementSpan and link handling within the Snowball app, providing developers with a comprehensive guide to advanced text styling.
Yang Chunwen shows how developers can quickly build a low‑cost, secure live‑streaming mini‑program on Tencent Cloud by using signed streaming URLs, off‑loading video processing to the cloud, and optimizing performance through batched setData calls, lazy image loading, and pre‑loading techniques.
Senior Tencent Cloud engineer Zhu Zhan explained the Mini Program solution, detailing its hybrid web‑native architecture, loading strategies, and the evolution from Wafer 1 to the managed Wafer 2 platform that simplifies session, channel, and business services, enabling rapid deployment and integration with WeChat.
The article explains why Android developers split large NDK‑generated .so files from the APK to reduce package size, outlines how to design comprehensive test points for dynamic loading, and provides practical suggestions for handling download, installation, compatibility, and upgrade scenarios.
In this talk, Tencent Video Cloud’s terminal‑technology director Chang Qing outlines how the company’s end‑to‑end audio‑video pipeline—capturing, digitizing, processing, encoding and transmitting streams—powers WeChat Mini Programs for live streaming, two‑way calls and interactive classrooms, offering faster iteration, richer customization and tighter WeChat integration than WebRTC.
This article explains how the Xposed framework works, why it normally requires root, and presents a technical approach using application sandboxing and dual‑app virtualization to enable Xposed modules on non‑root Android phones, including details of framework porting and hook mechanisms.
This article introduces the Xposed framework, explains its architecture and root‑based installation process, then explores alternative non‑root implementation methods using sandbox virtualization and Java hook techniques, detailing dual‑app virtualization, framework migration, and practical code examples for running Xposed modules on unrooted Android devices.
This article provides a comprehensive overview of Android’s layered architecture—including the application layer, framework layer, system libraries and runtime, and the Linux kernel—explaining each layer’s components, functions, and relevance for developers and testers.
This article analyzes the restriction mechanism of hidden APIs in Android P Preview 1 and presents three verified techniques—direct module provisioning, class‑loader manipulation, and access‑flag tampering—that allow developers to invoke system hidden APIs without triggering runtime warnings.
This article explains how Swift 4.0 introduced Codable, how Swift 4.1 added keyEncodingStrategy and keyDecodingStrategy to automatically convert between snake_case and camelCase, and how to implement custom key transformations such as PascalCase using the .custom strategy.
Tencent Cloud created a mobile assistant by integrating WeChat public accounts and mini‑programs, turning key console functions—account management, resource monitoring, and quick actions—into a unified, push‑notified experience that overcomes B2B operational, timing, and notification challenges, boosting efficiency for hundreds of thousands of users.
This guide walks through building a complete iOS VoIP solution using CallKit and PushKit, covering UI differences, step‑by‑step configuration of CXProvider and PKPushRegistry, handling incoming calls, common pitfalls such as lock‑screen crashes and token issues, and extending functionality with Call Directory extensions.
This article introduces four essential Android Studio plugins—.ignore, GsonFormat, CodeGlance, and 360 FireLine—that help developers manage .gitignore files, generate Java models from JSON, navigate code faster, and detect security or memory‑leak issues, thereby significantly improving productivity.
This article explains the iOS app launch process, breaks down dyld's loading stages, proposes concrete optimizations for dynamic libraries, rebasing, Objective‑C setup, and main‑thread work, and shows how these changes achieve roughly a 40% reduction in startup time on an iPhone 8.
This article introduces a self‑developed Android performance monitoring app, explains how to install, start, and view test results, and details the underlying data‑collection mechanisms for memory, battery, CPU, and FPS metrics, providing practical guidance for developers.
In late 2017 Tencent Cloud integrated its audio‑video SDK into WeChat Mini Programs, enabling developers to add live streaming, on‑demand video and real‑time calls—such as customer‑service video, court assessments, and insurance claims—through a cloud‑based upstream/downstream architecture that compresses streams, reduces latency, supports multi‑party RTC, and offers tools for moderation and recording.
The article explains how quick apps—lightweight, install‑free applications built on a native engine—are developed using Node.js and hap‑toolkit, compares them to web SPAs, demonstrates reusable layout components and a unified fetch wrapper, outlines system APIs, common pitfalls, and shows that a ten‑page Vivo Mall quick‑app with account and payment integration was built in about one week, delivering native‑like performance and rapid updates.
To avoid crashes and missing messages caused by newer Android restrictions on Toast—such as disabled notifications, BadTokenException on pre‑8.0 devices, and token‑null errors on Android 7.1—developers intercept Toast.show with AspectJ, replace it with a custom MToast, handle exceptions, and ultimately migrate to a robust Snackbar‑based notification system.
The article opens with Confucius' teachings on knowledge and inquiry, then presents a developer's issue where MotionPro VPN disconnects on Android, outlines two main causes—lack of app trust and background cleaning by phone managers—and provides clear steps to whitelist the app and reinstall it with trust enabled.
This article introduces the Quick App platform, explains its front‑end‑based architecture, provides a step‑by‑step Windows setup and project initialization guide, showcases UI layout and JavaScript code examples, compares it with Mini‑Programs and JDReact, and offers resources for developers interested in rapid, install‑free mobile app development.
This guide introduces Quick Apps, explains their front‑end‑centric architecture, walks through environment setup, project initialization, UI layout, JavaScript logic, debugging, deep linking, and compares Quick Apps with WeChat Mini‑Programs and JDReact, providing practical code snippets and tips for Android developers.
By walking through the creation of a custom Android Studio (IntelliJ) plugin that reads protobuf files and auto‑generates Service and Presenter classes, the author shows how VFS, PSI, and project‑model APIs can replace tedious manual coding, delivering roughly 5.5% time savings per requirement.
This guide explains why and how to use Google Protocol Buffers for efficient data exchange in iOS, covering environment setup, installation, .proto definition, compilation to Objective‑C files, project integration, and a complete encode/decode test with sample code.
This article details the design and implementation of an ARKit‑based hotel‑finding application for iOS, covering coordinate system concepts, conversion pipelines, elevation handling, directional hints, radar visualization, navigation routing, map/AR switching, and real‑time navigation alerts, accompanied by sample Objective‑C code.
This article introduces a PickerView library for Android, comparing it with existing libraries and providing examples of its usage in mobile applications.
The article outlines emerging iOS development trends for 2018, including ARKit-powered augmented reality, CoreML machine‑learning integration, Swift 4 enhancements, Apple Pay adoption, and HomeKit home‑automation, while reflecting on 2017's device releases and iOS 11 updates.
This tutorial walks through the complete Android MediaCodec workflow, covering creation, configuration, synchronous and asynchronous data handling, buffer management, and proper end‑of‑stream signaling for both encoding and decoding scenarios.
The article describes the background, architecture, and implementation details of a non‑intrusive Android SDK that monitors UI‑thread stalls, collects performance data, aggregates it on the server, and automatically generates work orders to help developers pinpoint and resolve lag issues efficiently.
This article explores Android’s MediaCodec API, detailing its role in hardware video encoding/decoding, buffer management, data types, lifecycle states, and practical code examples, providing developers with a comprehensive guide to implementing advanced video processing features such as watermarking and transcoding on mobile devices.
The article examines why short‑video list pages drain far more battery than detail pages, explains Android power‑profile calculations and testing with Battery Historian, and demonstrates code‑level fixes—replacing heavy layout animations with ValueAnimator—to dramatically reduce CPU‑intensive rendering and improve app battery efficiency.
The article details Ctrip's engineering solution for incremental offline package updates in its travel app, covering package creation, management, differential patch generation, download strategies, installation, monitoring, and practical challenges to achieve high success rates on iOS and Android.
This article explains the causes and trigger conditions of Android ANR, describes the underlying message‑driven mechanism, and compares four popular detection approaches—BlockCanary, ANR‑WatchDog, SafeLooper, and FileObserver—highlighting their advantages, limitations, and practical usage recommendations.
This article details DingTalk's Android accessibility journey—starting in mid‑2017, collaborating with the Shenzhen Information Accessibility Research Association, leveraging TalkBack, implementing contentDescription, focus navigation, custom views and services, and emphasizing thorough testing—to empower millions of visually impaired users in China.
This article explains how to obtain iOS diagnostics battery data on iOS 10+ and iOS 9 devices, interpret the SQLite tables to measure app power consumption, and provides practical code and performance‑optimization tips for reducing energy usage in iOS applications.
This article explains the Android Paging Library’s architecture—including DataSource variants, PagedList configuration, and PagedListAdapter integration—showing how to efficiently load large data sets from single or multiple sources while handling threading, prefetching, and UI updates.
This article explains why Android UI lag hurts user experience, reviews traditional adb‑based detection methods, introduces a new in‑app monitoring system that leverages Looper log matching and Choreographer.FrameCallback to capture precise stack traces, and describes its implementation, performance impact, data processing pipeline, and real‑world results.
This article explains how React Native handles network requests differently from web browsers, describes the built‑in fetch, XMLHttpRequest, and WebSocket APIs, outlines debugging methods using proxies, Reactotron, and Chrome DevTools, and discusses strategies for sending binary data such as Base64 encoding and WebSocket support.
The Android Checkout library wraps Google Play’s In‑App Billing API, providing a streamlined, lifecycle‑aware interface that handles service binding, request queuing, caching, purchase verification, and pagination, while exposing core classes such as Billing, Request, Checkout, Inventory, and configuration to simplify integration despite added synchronization overhead.
The article compares Android’s SurfaceView, GLSurfaceView, and TextureView for picture‑in‑picture video playback, explaining each view’s rendering model, the hole‑punch limitations of SurfaceView, Android N’s synchronous updates, and TextureView’s full transformation support at higher power cost, to guide developers in choosing the optimal solution.
This article provides a comprehensive guide to Android's Room persistence library, covering the creation of Entity classes, defining Data Access Objects (DAO), building the RoomDatabase, handling foreign keys, embedded objects, query methods, LiveData and RxJava return types, as well as database migrations and type converters for complex data types.
This article explains why the Suning+ Android app adopted the MVP pattern, details each layer's responsibilities, showcases the project’s multi‑layer structure, directory layout, and code snippets, and demonstrates how MVP reduces coupling and accelerates iterative development.
This article explains the principles of TCP long connections, compares NIO and BIO models, and describes how Android applications can implement and share persistent connections using AIDL, process sharing, and a dedicated SDK to support push, IM, and other real‑time services.
This article presents a comprehensive solution for capturing network packets on Android devices without rooting, compares tcpdump, Fiddler and VPNService approaches, describes a cloud‑based architecture using Go, MongoDB and libpcap, and details multiple performance optimizations that eliminate packet loss and dramatically increase CPU utilization.
This article details Meitu's comprehensive DNS optimization for Android apps, comparing LocalDNS and HTTP DNS, describing metric‑driven strategies, caching mechanisms, and a non‑intrusive SDK that works in both Java and native layers while handling HTTP, HTTPS, and SNI challenges.
This article outlines practical techniques for creating high‑performance Android apps, covering minimal library usage, streamlined design resources, asynchronous loading, build‑time reductions with ProGuard, and the importance of thorough discussion before implementation.
This article introduces Google’s ARCore platform, compares it with Apple’s ARKit, explains its relationship to Tango, details its core capabilities such as motion tracking, environmental understanding and light estimation, showcases several demo experiences, and outlines the key ARCore API components for developers.
The article details Android’s touch‑event pipeline, tracing how a physical press generates a GPIO interrupt, is read by Linux /dev/input drivers, passed through the kernel’s EventHub to the InputManagerService, dispatched by InputDispatcher, routed via WindowManagerService and InputChannel to ViewRootImpl, and finally delivered to the target View, helping developers debug and customize input handling.
This article demonstrates how to automatically enable USB debugging on a non‑root Android phone after reboot by installing a high‑permission app that uses an AccessibilityService to detect the debug state, launch the developer options, and simulate user interactions to toggle the setting.
The article analyzes the chaotic state of Android push notifications in China, explains the government's United Push Alliance initiative, details the proposed unified SDK architecture, and offers practical guidance for developers to build efficient, user‑friendly, and secure push systems.
This article examines Android's quality image compression, detailing Bitmap.compress() behavior, the Skia engine's role, Huffman coding optimization, libjpeg settings, and differences from iOS, while recommending newer libraries and techniques for improved compression efficiency.
This article explains how to reuse host‑app functionality via dependency injection, develop and debug React Native modules with TypeScript, and deploy updates both statically and dynamically using CodePush, while sharing best practices for crash handling and version compatibility.
JSSDK is a development tool that enables H5 developers to quickly build apps by facilitating app invocation, cross-platform compatibility, and parameter handling, reducing development time and complexity through modular design and automated version management.
Through a series of Gradle‑based benchmarks on clean, daemon‑enabled, and incremental builds, this study compares Java and Kotlin compilation times, revealing that while Java is slightly faster on cold builds, Kotlin matches or exceeds Java in typical incremental scenarios.
This article explains the principles of SQLite’s Full‑Text Search extension, details WeChat’s architecture for mobile search, and shares practical performance‑tuning techniques—including custom tokenizers, offset function improvements, and SQL‑level ranking—to achieve sub‑50 ms query times on billions of records.
This article explains the iOS code‑signing process for developers, covering Apple developer account enrollment, certificate creation, private key generation, provisioning profile types, automatic signing in Xcode, and step‑by‑step re‑signing of IPA files using the codesign tool.
This article explains how the Yuewen Game SDK was transformed into a pluginized architecture, detailing the motivation, core technical challenges such as class, resource, and Android component identification, implementation strategies, testing procedures, and the benefits and new issues arising from large‑scale deployment.
A recent Realm survey of around 100,000 developers shows Kotlin’s rapid rise in Android apps, predicting it will surpass Java as the primary language by the end of 2018, driven by Google’s official support and Kotlin’s modern, concise syntax.
This article explains the Android ANR mechanism, common scenarios that trigger it, how the system detects and logs ANR events, and provides step‑by‑step methods for locating and fixing ANR issues, illustrated with a recent WeChat bug example.
Google’s ARCore SDK offers motion tracking, surface detection, and light estimation for Android, supports a limited set of phones but can be extended to unsupported devices via a reverse‑engineered class hack, and competes with Apple’s ARKit and Google’s earlier Project Tango by delivering comparable AR features without specialized hardware.
This article provides comprehensive iPhone X UI design guidelines, covering screen dimensions, safe‑area layout, status‑bar adjustments, home‑indicator considerations, color gamut updates, Face ID integration, custom keyboard rules, larger navigation bars, and resources for designers and developers.
This article introduces JD's Aura component framework, detailing its origins, four foundational pillars, three supporting systems, key tools, SDK specifications, and the associated portal, CI, and management platforms that enable scalable Android componentization within the Avatar ecosystem.
This article explains the fundamental problems an Android plugin framework must solve—component representation, class loading, resource handling, inter‑module calls, resource sharing, and packaging—and describes Aura's design choices and implementation strategies for each of these challenges.
The article explains how the Aura framework handles plugin compilation and packaging by managing shared resources through public.xml, assigning unique package IDs, and offering two solutions—modifying AAPT and using the Gradle aura‑plugin—to achieve small, independent Android plugin bundles.
Lottie, Airbnb’s open‑source animation library, parses After Effects‑exported JSON to render vector animations natively on Android, iOS, and React Native, letting developers share a single asset across platforms, simplify code, manage assets from assets, SD card or network, while balancing modest APK size increase against performance limits for complex scenes.
This article provides a comprehensive guide to Android system features relevant to testing, covering common functions like app management, developer options such as USB debugging and various adb commands, process statistics, visual debugging tools, and the handling of normal, dangerous, and special permissions.
This article details JD.com's three‑platform JDReact solution built on React Native, describing the original mobile development pain points, RN's benefits and limitations, the customized architecture, performance and memory optimizations, gray‑release and fallback mechanisms, CI/CD workflow, and monitoring practices that enable stable cross‑platform app delivery.
This article introduces Android NDK fundamentals, explains the Android layered architecture, clarifies the roles of SDK, NDK, and JNI, and provides a detailed step‑by‑step tutorial for creating and debugging native C/C++ projects in Android Studio.
The article explains why an Android app may start several processes, causing Application.onCreate() to execute multiple times, and presents various techniques—including android:process configuration, process‑specific initialization, getRunningAppProcesses(), UsageStatsManager, and the AndroidProcesses library—to reduce startup latency and manage running processes across different Android versions.
This article introduces the Aura plugin framework used in mobile development, detailing its four main components: Aura Engine, Tools, SDK, and Support Systems, along with their roles in enabling plugin development and management.
This article explains the major challenges tackled by the Aura Android plugin framework—including component representation, class loading, resource handling, host‑plugin interaction, and packaging—and outlines how solving these enables building a generic, scalable plugin architecture for mobile apps.
This article discusses memory optimization in Android apps by addressing excessive object allocations caused by autoboxing Long values, leading to performance issues during feed scrolling. The solution involves implementing a custom data structure to reduce memory usage and improve application responsiveness.
The article introduces JD’s iOS Mocker, a server‑side mock service that decouples client development from backend progress, provides comprehensive mock data for all shopping‑flow interfaces, improves testing efficiency, ensures UI robustness, and outlines its architecture, usage workflow, and future extensions.
This article explains the design and implementation of Permissions4M, an Android library that uses compile‑time annotations to simplify runtime permission handling, covering the pre‑compilation, compilation, and post‑compilation stages, module structure, key code snippets, and usage patterns.
This article explains how to measure, analyze, and dramatically improve iOS app launch performance through profiling, removing unused code, compressing assets, and restructuring view controller loading, illustrated with a real‑world WiFi manager case study.
This article explains Kotlin's generic type system, collection interfaces, variance with in/out keywords, collection initialization methods, and the extensive set of operators, providing code examples and implementation details to help developers master Kotlin's core language features.
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 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 presents Ctrip's mobile call‑center solution, detailing its system architecture with SBC integration, the network challenges of mobile environments, the optimized SIP protocol, the custom CCodec audio codec with dynamic bitrate and low latency, and a real‑world deployment using PhoneSDK.
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 article explains Kotlin's class extension functions, highlights pitfalls of static resolution, demonstrates smart casts, describes companion objects and singleton patterns, and shows how to implement dynamic proxies and pseudo‑multiple inheritance with practical code examples for Android development.
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 explains how to capture and analyze native crashes on Android by using signal handlers, alternate stacks, and tools like dladdr and ptrace, while also showing how to retrieve Java stack traces and integrate crash information for robust mobile debugging.
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.
The article explores the evolution and core concepts of responsive architecture for iOS, explains immutability and its model layer, examines Flux as its foundational pattern, and provides practical guidance on integrating responsive design into existing mobile app architectures.
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 guide walks Huawei competition participants through the essential steps for building a video app, covering user‑need analysis, UI simplification, backend setup, performance considerations, screen adaptation, messaging, precise marketing, and experience measurement, while providing useful resource links.
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 tutorial introduces Apple’s ARKit platform introduced at WWDC 2017, explains the required hardware and iOS version, walks through creating an Augmented Reality App project in Xcode 9, importing 3D models, configuring plane detection, and rendering a virtual cup on a detected horizontal surface using ARSCNView.
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.
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.
