This article demonstrates how a non‑programmer can use the DeepSeek‑powered “AI Programmer” mode in Tongyi Lingma to generate, modify, and deploy a functional WeChat mini‑program entirely through natural language prompts, complete with screenshots of each step.
This tutorial explains how to capture any Android view—whether displayed, off‑screen, or generated programmatically—into a Bitmap, draw it with Canvas, and then save or share the resulting image, covering multiple view types and Android version compatibility.
The tutorial walks developers through adding the new alpha‑stage viewfinder‑compose and camera‑compose libraries, configuring permissions with Accompanist, creating a CameraPreviewViewModel that manages CameraX preview use cases, and building a full‑screen, Compose‑based camera viewfinder using CameraXViewfinder for adaptive APIs and animations.
Wise’s 2025 tech stack overhaul details how its 850‑engineer team leverages cloud‑native tools like Kubernetes, Terraform, and AWS, modernizes frontend with Next.js and Storybook, accelerates mobile builds via Swift Package Manager and Gradle, and integrates AI, data pipelines, and observability to support 12.8 million active customers worldwide.
This article documents how the author leveraged the Trae AI‑powered IDE to quickly create a three‑page WeChat mini‑program, detailing project setup, code generation, interactive AI assistance, and the resulting development experience.
The article presents a hybrid native‑container/Weex 2.0 architecture for Taobao’s transaction terminal that tackles native development inefficiencies by using configuration‑driven modules for container, instance, data, resource, and logic management, achieving up to 70% latency reduction and outlining rollout and future optimization plans.
One‑click mobile number login streamlines user authentication by leveraging carrier‑provided phone number masks and tokens, eliminating passwords and verification codes; this article explains the underlying PPP‑based network principles, the multi‑stage token exchange flow, and integration considerations across China’s three major operators.
Soong, Google's declarative build system replacing Android.mk, offers faster incremental and parallel builds, structured dependency management via .bp Blueprint files, and seamless integration with legacy Make, providing Android developers with a scalable, efficient way to configure and compile system components.
This article outlines five common Android SDK development methods—Jar, SO, AAR, Dex‑plugin, and Apk‑installation—detailing their structures, integration steps, code examples, and best‑practice principles such as stability, minimal dependencies, small package size, optimal performance, compatibility, and dynamic updatability.
The article explains the principles of dependency injection, compares the DI frameworks Koin and Hilt in terms of integration difficulty, performance, cross‑platform support, IDE tooling, and maintenance, and concludes that Koin offers a simpler, lighter, and more versatile solution for Android and multiplatform projects.
This article explains how to configure AndroidManifest.xml for TV apps, use Focus and FocusableActionDetector to manage TabBar selection, handle remote control key events with KeyboardListener, and implement long‑press detection in Flutter for Android TV development.
This article compares the diff and UI update mechanisms of Flutter and Jetpack Compose, explaining Flutter's Element‑based linear reconciliation and Compose's Composer‑driven SlotTable with gap‑buffer diff, while illustrating each step with code snippets and diagrams.
Learn how to dramatically improve the speed and responsiveness of your WeChat Mini Program by applying twelve practical optimization strategies, including first‑screen loading, data preloading, image handling, setData reduction, event throttling, selector queries, component lifecycles, list rendering keys, caching, timers, IntersectionObserver, and network request management.
This article surveys the most promising development stacks for 2025—including MERN, MEVN, JAMstack, T3, Flutter, PERN, Python‑Django, DevOps, AI/ML, blockchain, Spring Boot + React, and Rust—explaining why each stack is worth learning, its key advantages, and the tools that make it powerful for modern developers.
This guide walks you through DevEco Studio 5.0.1's refactoring capabilities—renaming, safe deletion, and extracting methods, constants, interfaces, and variables—to streamline HarmonyOS app code, improve structure, and boost development efficiency.
This guide demonstrates how to use the ohos.request module in HarmonyOS NEXT API 12 to upload a local file through a custom proxy by creating a proxy agent, reading the file, configuring request options, and handling responses and errors.
This article provides a comprehensive introduction to Android NDK development, covering JNI fundamentals, data type mappings, method registration (static and dynamic), JNIEnv usage, CMake build configuration, and multiple practical code examples in Kotlin, C++, and C.
The article offers a comprehensive guide to iOS disk management for app developers, explaining the sandbox’s Documents, Library (Caches and Application Support) and tmp directories, proper storage practices, APIs for directory access, disk‑size calculation, iCloud backup exclusion, and both automatic and manual cleanup strategies including system cache handling.
This guide explains the WeChat Mini Program review workflow, lists the most frequent rejection reasons such as missing privacy policies, incomplete content, mismatched categories, and provides concrete steps—including code adjustments and documentation tips—to dramatically improve approval chances.
This article explains the HarmonyOS NEXT Background Tasks Kit, detailing its four task types—Transient, Continuous, Deferred, and Agent‑powered Reminder—along with their characteristics, typical use cases, and complete ArkTS code examples for each scenario.
This article explains the concept of "same‑frequency same‑frame" animation, analyzes the limitations of existing animation engines, and presents a Drawable‑based projection technique with code examples to synchronize animation frames across multiple Android views while reducing memory and CPU overhead.
This guide demonstrates how to strip splash-screen ads from an Android game by decompiling the APK, locating and altering the launch activity in AndroidManifest.xml, and recompiling the app, offering a practical reverse-engineering workflow for mobile developers.
This tutorial explores SwiftUI's transition mechanisms—including AnyTransition, the new Transition protocol, visualEffect modifiers, shader‑based effects, color gradients, text rendering, scroll‑based and navigation transitions—providing step‑by‑step code examples and practical guidance for creating impressive UI animations.
This guide explains the background of HarmonyOS NEXT, introduces Alibaba Cloud ARMS Real User Monitoring SDK for native HarmonyOS apps, details its page, resource, exception, and custom data collection features, and provides step‑by‑step integration instructions with code examples.
This article demonstrates how to create a smooth color‑gradient animation for an Android view by dynamically configuring a GradientDrawable and driving the transition with a Kotlin PropertyAnimator, including code examples and step‑by‑step explanations.
This guide explains why Charles combined with Postern is preferred for Android app packet capture, details the required environment, step‑by‑step configuration of Charles and Postern, SSL proxy setup, certificate installation and migration, and compares the solution with Fiddler.
This article details Ctrip's migration of its large‑scale React Native (RN) codebase to HarmonyOS using the custom CRN framework, covering technology selection, version upgrades, native component re‑implementation, component C‑ization, performance optimizations such as pre‑loading, TurboModule worker threads, instruction pruning, and future roadmap.
This article details JD's custom HarmonyOS image library built with C++ and Taro, covering its background, technical design, core modules, performance monitoring, optimization techniques, quality assurance mechanisms, and future development plans to achieve high‑performance cross‑platform image loading for mobile applications.
This guide explains two primary techniques—using the Navigation component and the router object—to pass parameters between pages in HarmonyOS NEXT, providing step‑by‑step code examples, practical scenarios, and tips for choosing the appropriate method.
This article demonstrates how to build a Python-based Douyin crawler that uses ADB to control an Android device, captures screenshots, employs Baidu AI face recognition to detect high‑scoring female faces, and automatically likes videos meeting the criteria.
This article explains HarmonyOS concurrency concepts, covering async patterns with Promise and async/await, the Actor model for multithreading, and practical usage of TaskPool, Worker, and the @Concurrent decorator with code examples to improve app responsiveness and performance.
This article explains the basic concepts of Android power consumption, the components that contribute to battery drain, the role of power_profile.xml, and various measurement methods such as PowerMonitor, dumpsys batterystats, system power ranking, and Battery Historian, providing practical steps and tools for developers to analyze and optimize app energy usage.
APNG, a high‑quality animated PNG format offering 24‑bit color and 8‑bit alpha transparency, outperforms GIF in visual fidelity and file size, and on Android can be parsed and rendered via MappedByteBuffer and SurfaceView using background threads to load frames from memory, eliminating I/O lag and UI blocking.
This course, designed for developers with basic front‑end experience, teaches how to combine the uniapp framework and ThinkPHP backend to build high‑performance, cross‑platform mobile applications, covering topics such as data modeling, token authentication, middleware, API design, pagination, and deployment.
This article details how Ctrip’s Market Insight platform leveraged the Donut framework to build a high‑performance, cross‑platform mobile application, covering background, technical challenges, technology selection, development workflow, multi‑login management, large‑list rendering optimization, push integration, build and release processes, encountered pitfalls, and the resulting efficiency and performance improvements.
This article explains how the Huolala mobile team built a stable symbol demangling system using the open‑source symbolic‑demangle tool, covering the concepts of name mangling, why symbolic was chosen, step‑by‑step adaptation for newer Swift versions, Linux Python‑wheel building, and practical troubleshooting tips.
This article describes how Tubi's Android team redesigned their video player with a modular, distributed architecture—introducing PlayerContext, PlayerHandlerWrapper, and composable modules for ads, event tracking, and TTS—to improve flexibility, testability, and scalability while sharing lessons learned from the refactoring process.
BlockFramework is an open‑source Android client‑side framework that decouples business logic into reusable Blocks, offering clear separation, tree‑based UI assembly, rich communication patterns, unified development standards, and high‑performance features such as asynchronous view inflation and data binding.
This tutorial explains UIStackView, Apple’s iOS 9 linear layout container that mirrors Flexbox concepts, covering axis, distribution, alignment, and spacing, showing how to add arranged subviews, hide them dynamically, adjust hugging and compression priorities, and noting its limitations such as lacking order, flex‑grow, and flex‑basis controls.
The article reviews the Android Studio 2024.2 (Ladybug) release, detailing versioning changes, IntelliJ 2024.2 improvements such as K2 mode, the new default UI, enhanced Git options, AI‑driven terminal, updated emulator support, Feature Drop deprecations, and practical migration tips for developers.
By unifying the live‑room player with a same‑layer rendering component, exposing real‑time data through a communication layer, and using a pool‑based multi‑instance architecture that adapts to tablets and foldable screens, developers can embed native‑like immersive live rooms directly into H5 pages, simplifying integration and enabling future AI‑driven features.
Android Dynamic Performance Framework (ADPF) lets apps and games send performance‑hint data—such as target work durations and preferred cores—to the kernel, enabling faster CPU frequency scaling and priority scheduling that mitigates the latency of PELT/WALT and DCVS, while developers use APIs like createHintSession and reportActualWorkDuration, though adoption remains limited.
This article explains Bluetooth Low Energy fundamentals, compares classic and BLE, describes BLE mesh networking, provides a complete bleno example for peripheral simulation, and details advertising, scanning, connection flow, MTU negotiation, fragmentation, and sticky‑packet handling on Android and iOS.
This article details JD Finance’s end‑to‑end migration of its financial app to HarmonyOS NEXT, covering the system’s architecture, component selection, cross‑platform strategies, performance optimizations, new OS features, and lessons learned from the trial and official releases.
This guide explains how to configure a Swift‑only target, define ActivityKit attributes, implement lock‑screen and Dynamic Island UI with ActivityConfiguration, manage creation, updates, and dismissal, handle permissions and server‑side push payloads, and work around network‑image restrictions using shared App Group storage.
Hvigor is a TypeScript‑based build orchestration tool for HarmonyOS that manages tasks, project models, and configurations, integrates with DevEco Studio for consistent command‑line and IDE builds, supports lifecycle phases, custom tasks, plugins, and routing plugins, and provides detailed development guides and code examples.
This article introduces HarmonyOS NEXT's Intent Framework, explains its distribution capabilities such as habit and event recommendations, skill invocation, and local search, showcases practical scenarios including movie ticket reminders and JD Finance services, and provides step‑by‑step integration instructions with code examples.
The article explains how the open‑source ohos_react_native project brings React Native 0.72.5 to OpenHarmony, detailing its support for the New Architecture, Fabric rendering, C‑API performance gains, TurboModule variants, and the current migration status of related packages.
This article explains the background, architecture, core processes, and engineering challenges of Baidu's Android instant‑messaging SDK, detailing how the public IM system, long‑connection layer, and modular components enable reliable, real‑time communication across multiple devices.
This article explains the architecture and implementation of the Roma dynamic cross‑platform solution, covering its JavaScript‑VM based rendering pipeline, HarmonyOS integration challenges, resource packaging, view creation across JS, C++, and ArkTS layers, and the diff‑based update mechanism that enables seamless UI updates on multiple platforms.
This article explains how a $25 fold‑able wireless keyboard, combined with Tailscale VPN, Blink Shell SSH client, and AirPlay mirroring, lets you use an iPhone as a lightweight laptop for blogging, coding, and remote work while traveling.
This article explains how to analyze React Native bundle contents, customize Metro's module ID generation to achieve stable code splitting, and integrate the resulting base and feature packages with a hot‑update workflow that preloads the base bundle, loads feature bundles on demand, and handles loading failures on iOS.
This article walks you through the entire process of registering, filing, and certifying a personal WeChat Mini Program, covering account type selection, publishing steps, filing requirements, MIIT SMS verification, and common pitfalls to avoid.
This article explains how to build an eye‑catching falling confetti animation in Flutter by defining a ConfettiPiece class, using HookWidget for state management, CustomPaint for rendering, LayoutBuilder for responsive sizing, and a periodic timer to animate the pieces, with customizable parameters for color, size, and speed.
This article explains how to handle iOS Live Photo assets in Flutter by extracting the HEIC image and video components, synchronizing gesture‑driven scaling and translation, and managing playback during slide‑out and gesture interactions, complete with detailed code examples.
This article details JD Finance's end‑to‑end development of a HarmonyOS NEXT version, covering background, feature selection, architectural layering, technical solution comparison, infrastructure construction, challenges, trial and official releases, new OS features, performance optimization, and future plans.
The team maintains an ‘opt’ branch for daily‑collected crash fixes, classifies unrecoverable system, device, SDK and framework errors, and employs a Handler‑based whitelist that catches and swallows known crashes while logging others, complemented by null‑safety, concurrency, database and OOM monitoring to keep Android app crash rates manageable.
Airbnb’s Android Page Performance Score (PPS) framework instruments fragments to collect user‑centric metrics such as TTFL, TTIL, MTH, ALT and RCLT, using a standardized logging config, LoadableView interface, and visibility algorithms, enabling detailed performance analysis and automated alerts for mobile teams.
This article explains how to create and configure route interceptors, use lifecycle callbacks, and manage global navigation in Flutter applications, providing code examples for single‑page and global interceptors, route lifecycle states, extended route observers, and best‑practice recommendations.
Software architecture defines a system’s structural organization and its evolving design process, encompassing elements such as systems, modules, components, relations, and subsystems, and can be realized through vertical layered (presentation, business, data, base) or horizontal modular approaches that promote decoupling, testability, and maintainability while following the fit, simplicity, and evolution principles and supporting cross‑platform and dynamic implementation options.
Baidu built a unified Android IM SDK and public instant‑messaging system that consolidates login, message routing, synchronization, notifications, and group chat into reusable client and server components, using a hybrid push‑pull model to deliver real‑time, secure communication while dramatically lowering development and maintenance costs across its product portfolio.
This article explains the step-by-step process for upgrading Flutter to version 3.24, covering preparation, environment configuration, known pitfalls, API changes, new features, and code adjustments to ensure a smooth migration for mobile developers.
This guide outlines the comprehensive technology stack a full‑stack developer needs, covering front‑end frameworks, back‑end languages and frameworks, databases, mobile development, cloud platforms, UI/UX tools, and DevOps practices for building modern applications.
JD leveraged the Taro cross‑platform framework to build a HarmonyOS native app, detailing the background partnership with Huawei, the technical solution choices, key features like Web‑style development, CSS optimizations, virtual lists, and mixed native modules, and presenting performance gains and future optimization plans.
This article shares a detailed experience of publishing a Flutter‑based logistics application across major Chinese app stores, analyzes the difficulty levels and specific review issues for each platform, and provides concrete recommendations to avoid common pitfalls and streamline the submission process.
This article explains how JD adopted the Taro cross‑platform framework to build HarmonyOS native applications, detailing the background, technical方案, key features, performance results, and future optimization plans for delivering high‑performance mobile experiences.
The article details JD's adoption of the Taro cross‑platform framework to build a HarmonyOS native app, describing the technical architecture, CSS and rendering optimizations, performance gains over native ArkTS, and future plans for further speed and flexibility improvements.
The article details JD’s 2024 initiative to build HarmonyOS native applications using the cross‑platform Taro framework, describing the chosen technical solution, key advantages such as Web‑style development, CSS optimizations, rendering performance, virtual list support, and future optimization plans.
SQLite, the lightweight embedded SQL engine created in 2000, is the world’s most deployed database, powering mobile apps, embedded systems, desktop software, data analysis tasks, and even browser‑based acceleration via WebAssembly, thanks to its zero‑configuration design and broad language support.
Airbnb’s iOS Page Performance Score implementation introduces a PPSStateMachine that ties a UIViewController’s lifecycle to metric collection—tracking first layout, initial load, scroll thread hangs, additional and rich content load times—using nanosecond timestamps, state‑machine protocols, and view‑responder discovery to emit standardized performance logs.
Apple’s 2024 policy change let the UTM SE emulator, which uses a threaded interpreter instead of JIT, run Windows XP and other OSes on iPad, iPhone and VisionOS, though the app is about 60 % slower than full UTM and feels sluggish, yet classic games still play smoothly.
This course provides a comprehensive guide to developing rich WeChat Mini Program applications by teaching learners how to use and customize a wide range of built‑in and extended components, covering fundamentals, UI design, data binding, and practical project implementation.
GetX Scaffold is a rapid development scaffold built on the GetX framework for Flutter, offering a comprehensive template with global methods, extensions, widgets, internationalization, and network utilities to accelerate app development across multiple Flutter versions.
The article walks through creating a firework‑style animation for Android like buttons by building a custom ParticleDrawingView that renders launch particles and exploding spark groups on a Canvas, using ValueAnimator with configurable durations and interpolators to control four animation phases and particle properties such as position, velocity, alpha, and rotation.
This guide details how Sohu News integrated HarmonyOS push notifications—covering DevEco Studio setup, certificate generation, profile configuration, client ID metadata, permission requests, token retrieval, and handling cold‑ and hot‑start push data—using the HarmonyOS NEXT SDK and AppGallery Connect services.
Kotlin Multiplatform enables developers to share a single Kotlin codebase across Android, iOS and the new Harmony Next OS—avoiding costly full rewrites—by converting Harmony OS TypeScript definitions to Kotlin, compiling to JavaScript or native binaries, though challenges remain in debugging, library compatibility, bundle size and threading support.
This article explains how to build a lightweight mobile UI inspector for iOS and Android by using a Flask backend to serve screenshots and XML UI trees, converting them to interactive HTML with jQuery, and adding synchronized hover highlighting through randomly generated identifiers.
This article provides a comprehensive guide to Flutter animations, covering fundamental concepts, terminology, core animation APIs, step‑by‑step code examples for scaling, rotating, looping, custom curves, staggered animations, and additional widgets, helping developers create smooth and interactive UI effects on mobile platforms.
In Flutter, MediaQuery.of(context).padding.top reports the system UI inset rather than the actual status‑bar height, and when a Scaffold (especially with an AppBar) consumes this padding the value becomes zero, so developers must read the raw view padding via WidgetsBinding or MediaQueryData.fromView to reliably obtain the status‑bar height.
This article recounts a small startup’s journey from selecting uni‑app for cross‑platform mobile development and egg.js for the backend, through mid‑project adjustments, hiring challenges, and practical team‑management advice, highlighting lessons to avoid common pitfalls.
This tutorial walks you through creating a basic HarmonyOS notepad application using the native ArkTS language and ArkUI components, covering project setup, directory structure, UI layout, routing, and implementing add‑and‑delete functionality with complete code examples.
This article explains why the author chose to learn Flutter for cross‑platform app development, outlines a step‑by‑step Windows environment setup (including SDK download, PATH configuration, mirror sources, and IDE installation), and provides a detailed line‑by‑line explanation of the default main.dart demo with code snippets and suggestions for extending the sample.
An Android app that stores shop‑sign photos began corrupting WebP images at a stable 1/200 rate, leading to a thorough investigation of the storage module, AES encryption implementation, and thread safety, ultimately uncovering a faulty string‑length check that broke binary image handling.
This article explains why SQLite, the lightweight embedded relational database, is the most widely deployed database in the world, detailing its origins, core features, and diverse usage scenarios across mobile, embedded, desktop, data analysis, and web acceleration contexts.
This article examines the characteristics of mobile application development for supply‑chain logistics, covering device framework selection, backend service design, operational backend functions, and scenario‑driven user experience optimization, while highlighting differences from traditional PC web solutions.
This article provides an in‑depth tutorial on using the GetX library for Flutter, covering its state‑management, routing, dependency‑injection features, code generation tricks, common pitfalls, and a step‑by‑step rewrite of a WanAndroid project with practical examples.
This article explains how FlutterUnit leverages TolyUI to create an interactive Layout Playground, detailing the data, view, and logic layers of the Flex Playground, including state management, component composition, and code examples for building flexible UI demos.
Introducing NestedScrollFrameLayout, a FrameLayout subclass that implements NestedScrollingChild, enables any wrapped view to participate in Android nested scrolling—including touch and fling—without modifying the child, offering one‑click integration, smoother continuous scrolls, and dramatically lower development and maintenance costs.
This article shares a comprehensive overview of HarmonyOS Next's key features, compares its development approach with Android and iOS, and details practical experiences, tools, and lessons learned while building the first version of the Zhaozhuan app, including WebView integration and future plans.
This article explains Android ANR (Application Not Responding) fundamentals, detailing its four types, underlying causes such as main‑thread blocking and deadlocks, the system’s timeout mechanisms, step‑by‑step analysis workflow, trace interpretation, and practical best‑practice tips to prevent and resolve ANR problems.
Kuaishou VP App, the first short video platform on Apple Vision Pro, offers immersive features like spatial gestures and 3D likes, leveraging visionOS for enhanced user interaction.
Cocoapods‑sled is a lightweight CocoaPods plugin that caches Xcode build artifacts and automatically converts reusable pods to binary form, offering low‑cost integration, local caching, binary handling, and full pod reuse to accelerate iOS development workflows.
The article examines Kotlin Multiplatform’s language design, its three dedicated compilers, artifact structure, and plugin ecosystem, critiques Gradle’s build‑system shortcomings, and details the team’s Bazel migration that delivers faster incremental builds while highlighting trade‑offs and future improvements for Kotlin‑Native, JS inter‑op, and tooling.
Huawei unveiled the fully self‑developed Cangjie programming language at the 2024 Developer Conference, detailing its native intelligence, full‑scene support, high performance, strong security, multi‑paradigm features, and simple syntax designed specifically for HarmonyOS applications.
The article recounts a developer’s experience in a small startup, detailing the rationale behind selecting uni‑app for cross‑platform mobile development, egg.js and MySQL for the backend, the challenges of rapid product iteration, team hiring, management practices, and practical advice to avoid common pitfalls.
The article shares a developer’s painful experience at a small startup, detailing the initial choice of uni‑app, egg.js, and antd‑vue, the subsequent technical and managerial turbulence, and practical advice on hiring, team management, and avoiding common pitfalls.
This article explores common performance bottlenecks of WebView and H5 pages in mobile apps and presents a comprehensive set of optimization strategies—including preloading, rendering tweaks, network enhancements, and memory management—to achieve near‑instant page loads and improve overall user experience.
This article explains the role of BuildContext in Flutter, how to safely use it across asynchronous operations, defines a global navigatorKey for context access, and demonstrates common properties, methods, and scenarios such as navigation, theming, media queries, dialogs, state management, and asset loading.
This article details the necessity of establishing a no-buried-point scheme mindset, key advantages over traditional methods, mobile client no-buried-point collection implementation mechanisms, data processing, and the benefits of this approach.
By migrating the CatEar FM live‑streaming app’s WebSocket layer to Chromium’s Cronet network stack, the team unified cross‑platform code, added customizable DNS and proxy support, and cut handshake latency by roughly 150 ms on Android and 250 ms on iOS, paving the way for future HTTP/2 and HTTP/3‑based WebSocket transports.
