This article introduces Android's AccessibilityService, explains its fundamentals, shows how to create, register, and configure the service, demonstrates common techniques such as node searching and interaction, and provides a complete Kotlin example that automatically logs into WeChat on Windows/Mac.
This article explains the differences between Java's Annotation Processing Tool (apt), Kotlin's annotation processor (kapt), and the newer Kotlin Symbol Processing (ksp) framework, illustrating their architectures, usage patterns, and code‑generation capabilities with practical examples for Android development.
This article details NetEase Yanxuan's Android team transition to a component‑based architecture, identifies inherent problems such as version control, quality assurance, semantic versioning and binary compatibility, and presents the YAC engineering solution—including standardized processes, Gradle plugins, CI/CD pipelines, and tooling—to streamline component development and improve productivity.
From 2010 to 2022 the Linux kernel moved from reactive, out‑of‑tree hardening to a proactive KSPP‑driven era, integrating probabilistic and deterministic mitigations, hardware‑backed defenses, and compiler‑level checks, while Android’s adoption and emerging Rust‑based components accelerated mainstream security hardening.
This article explains why the Kotlin Android Extensions plugin is deprecated, outlines migration strategies for legacy code, introduces the open‑source Kace framework as a seamless replacement, and provides detailed setup, code generation, performance optimizations, and incremental compilation techniques for Android projects.
This article explains how managing complexity by layering responsibilities and introducing an MVP architecture separates UI rendering from business logic in Android search features, illustrating the problems of high coupling and low cohesion with concrete Kotlin code examples and discussing AB testing and decorator patterns.
The article introduces the Switchquery configuration platform, describing its background, technical principles, real‑time delivery mechanism via HTTP header versioning, system architecture, integration steps for Android and iOS, optimization measures, and case studies demonstrating its impact on high‑traffic events.
Meta’s recent blog reveals its large‑scale migration of Android apps from Java to Kotlin, highlighting Kotlin’s advantages, the challenges of mixed codebases, tooling updates, and the strategic decision to convert most of its 10 million‑line codebase, offering valuable lessons for mobile developers.
Elon Musk’s public criticism of the Twitter app’s RPC usage sparked a heated response from Twitter’s engineers, who clarified that the app’s slowness stems from unused features, accumulated technical debt, and network latency rather than the alleged batch RPC calls.
The article uncovers a lock‑induced latency in Retrofit’s service‑method cache during cold‑start, demonstrates how moving the synchronization to a class‑level lock and customizing Retrofit.create eliminates the bottleneck, and then shows how dynamic‑proxy hooks combined with Kotlin coroutines can add transparent caching and low‑intrusion BFF aggregation without altering the library.
The article traces Taobao’s XSearch evolution from a rigid 1.0 scrolling container to a flexible 2.0 architecture built on NestedScroll, detailing unified data models, MetaLayout rendering, customizable headers, and reusable components that improve code reuse, extensibility, and consistent UI across multiple search scenarios.
This article explains how the Android Runtime (ART) implements the Java synchronized keyword at the native level, detailing the roles and interactions of Monitor, LockWord, and native Object classes, as well as the thin‑lock to fat‑lock upgrade process and monitor entry/exit mechanisms.
This article explains how to split Android components based on business functionality, handle strong and weak component dependencies, configure multiple UI themes, manage key‑value storage safely with MMKV‑KTX, and use routing frameworks judiciously to keep modular apps maintainable and scalable.
This article explains why monolithic Android projects suffer from long compile times, high coupling, and merge conflicts, and demonstrates how componentization—using a four‑layer architecture, unified Gradle dependencies, plugin switching, code isolation, ARouter routing, decentralized APIs, and AndroidX App Startup initialization—can solve these problems with concrete Kotlin and XML examples.
This article introduces AndroidMonitor, a lightweight Android packet‑capture library, explains how to add its monitor and monitor‑plugin dependencies, configure ProGuard, customize entry names, ports and logos, and optionally use AndroidLocalService to expose captured data via a local socket for both mobile and PC UI visualization.
This article demonstrates how to build a custom Android TextView that supports clickable topic spans, URL interception, and smooth expand‑collapse behavior using StaticLayout measurements, custom ButtonSpan labels, and optional height‑animation, providing a reusable solution for rich mobile text displays.
This article explains how the Kotlin Compose Compiler uses the intermediate representation (IR) to generate code, covering IR tree structure, traversal with visitors and transformers, and the process of adding composer parameters and restart groups via custom IrGenerationExtension plugins.
The Yanxuan app home page has progressed from a layered native architecture using Tangram and TAC to a component‑based system with compile‑time cell registration and asynchronous loading, and finally to a VirtualView‑driven dynamic UI that enables fast, cross‑platform updates, improved performance, and reduced release overhead.
This article details comprehensive strategies for handling massive seat‑selection data on mobile devices, covering data modeling, interface pre‑loading, static and dynamic compression, view hierarchy tweaks, bitmap reuse, drawing optimizations, hardware acceleration, and multithreaded task handling to dramatically improve load times and frame rates.
This article explains the fundamentals of Android pluginization, covering class loading, resource handling, Dex and OAT formats, security considerations, and presents a lightweight plugin framework used by 58.com to reduce app size and enable dynamic updates.
This article reviews three approaches to obtain the Android soft‑keyboard height—using ViewTreeObserver, a hidden PopupWindow, and WindowInsets—compares their pros and cons, shows complete Kotlin/Java implementations, and demonstrates how to attach UI elements to the keyboard for a smoother user experience.
Google announced that Android and Chrome will now support Passkey key‑login, a biometric‑based, public‑key authentication method that replaces traditional passwords, allowing users to create a secure credential on their device, sync it across platforms, and developers to integrate it via WebAuthn and related APIs.
Meta’s recent shift of its Android apps from Java to Kotlin reveals both the compelling benefits—such as null‑safety, concise code, and functional features—and the practical challenges like mixed codebases, tooling gaps, and longer build times, offering a detailed roadmap for large‑scale mobile language migration.
At 40, the author transitioned from a management role to Android development, sharing the challenges, learning strategies, and eventual success that prove it’s never too late to start a software development career.
Meta is converting its flagship Android apps from Java to Kotlin, citing benefits like reduced code size, safety, and better concurrency support, while navigating tooling challenges and showing a broader industry shift toward Kotlin for mobile development.
Google announced that Android and Chrome will adopt Passkey, a biometric‑based, public‑key login system that replaces traditional passwords, offering cross‑platform support, phishing resistance, and cloud‑backed recovery, with developers able to integrate it via WebAuthn and Google Play Services.
The article details Youku's comprehensive approach to making its video app accessible, covering unified component specifications, screen‑reader support, extensive testing, scoring mechanisms, content adaptations, and future plans that together create a sustainable, user‑friendly experience for visually impaired users.
This bulletin explains Flutter’s default null safety and migration steps, warns about code‑trim pitfalls that can bloat binaries, introduces EngineGroup for multi‑engine apps with its memory trade‑offs, and outlines Android foldable adaptation through guidelines, OEM solutions, and Android 12L activity embedding.
This article explains how the Compose compiler’s front‑end checkers—ComposableCallChecker, ComposableDeclarationChecker, and ComposeDiagnosticSuppressor—validate @Composable usage, handle inline lambdas, annotation retention, and named‑argument restrictions, providing code examples and visual diagrams to illustrate each rule.
This article explores the current market of foldable smartphones, classifies their folding mechanisms, examines user‑experience postures and scenarios, and provides practical UX design guidelines—including readability, accessibility, continuity, and layout techniques—to help designers create effective foldable‑screen applications.
This article explains how to reduce UI complexity in Android by layering architecture, tracing the evolution from MVC through MVP and MVVM to MVI, and demonstrates a searchable interface built with Jetpack Navigation and Kotlin DSL, highlighting pitfalls of monolithic initView methods and proposing more reusable abstractions.
This article explains the importance of mastering Gradle for Android development, describes what Gradle and build tools are, outlines its historical evolution and key characteristics, and provides a practical learning path with resources and future topics such as tasks, lifecycle, dependency management, and plugin development.
This article explains how Android native developers can capture and recover from controllable SIGSEGV crashes by registering signal handlers and using sigsetjmp/siglongjmp to emulate a try‑catch mechanism, complete with sample JNI code and practical considerations.
Google’s new Passkey system, introduced in Android and Chrome, combines biometric verification with public‑key encryption to create a cross‑platform, phishing‑resistant login method that syncs across devices and promises to replace traditional passwords.
The article explains Linux hung‑task detection, detailing both a system‑wide polling method that compares unchanged D‑state task context‑switch counts and a watchdog approach for critical processes, describes kernel implementations, analysis of real‑world hang cases, and emphasizes log analysis and parameter tuning to prevent system hangs.
This article explains how to employ the Java Virtual Machine Tool Interface (JVMTI) in native Android code to record memory allocation and deallocation events, filter relevant classes, store logs efficiently with mmap, and integrate the agent from the Java layer for comprehensive memory‑leak analysis.
The B‑Cut video‑editing app was transformed from a monolithic single‑project codebase into a component‑based modular architecture—introducing clear layers, Gradle‑driven unified configuration, independent library/application modules, strict dependency and resource conventions, and a fast‑compile system—thereby cutting build times, eliminating merge conflicts, and enabling reusable components across teams.
Thor is a unified Android container framework that combines Java and native hooking into a lightweight, dynamically loadable module, ensuring backward compatibility, hot‑plug plugin deployment, fault‑tolerant operation, and cloud‑controlled toggling, while real‑world plugins for threads, I/O, privacy, and memory deliver measurable performance and stability gains.
This tutorial walks through OCR fundamentals using pytesseract and chineseocr_lite, demonstrates how to push notifications via Server酱, provides reusable Python image‑processing utilities, and shows how to dump and parse Android UI XML for automated interactions.
This article analyzes the performance pitfalls of Android's SharedPreferences, explains how its apply() method can still cause ANR, introduces Jetpack DataStore as a modern replacement, and provides detailed migration strategies including code examples, coroutine handling, and bytecode transformation techniques.
The article explains how to use the collectAsStateWithLifecycle composable function in Jetpack Compose to collect Kotlin Flow data streams in a lifecycle‑aware manner, freeing resources when the app is backgrounded, and compares it with the traditional collectAsState API while providing code examples and migration guidance.
The article examines three Android Bluetooth stack flaws—CVE‑2020‑27024 in the SMP pairing protocol, CVE‑2021‑0918 in GATT notifications, and CVE‑2021‑39805 in L2CAP signaling—detailing their out‑of‑bounds memory errors, underlying code issues, and implications for future Rust‑based stack security.
iQIYI’s new Playback Kernel 5.0 introduces a decoupled pre‑decode component that creates a single hardware (or software) decoder and supplies pre‑decoded frames to multiple player instances, cutting start‑up latency from roughly 400 ms to about 35 ms and enabling true “zero‑second” playback across a wide range of Android devices.
This article explains how Jetpack Compose implements property animations by detailing the animateColorAsState function, its parameters, related animation helpers such as animateDpAsState and animateValueAsState, and the underlying Animatable, TargetBasedAnimation, and runAnimation mechanisms, complete with Kotlin code examples.
This article explores Jetpack Compose's visibility animation APIs by dissecting the AnimatedVisibility composable, its EnterTransition and ExitTransition parameters, the underlying Transition system, and related helper functions, while providing concrete Kotlin code examples and explanations of how each component works together to produce smooth UI effects.
This article explains Android image compression fundamentals—including ARGB, bitmap memory, bit‑depth vs. colour‑depth, quality and sampling compression methods—then details the Luban algorithm, its shortcomings, proposed improvements, and the underlying Skia/Huffman/JPEG native implementation with code examples.
This article provides a detailed introduction to Android Debug Bridge (ADB), covering its concepts, architecture, environment setup, common issues, command syntax, and practical automation examples using both shell scripts and Python, enabling developers to control devices, perform UI actions, and schedule tasks efficiently.
This article details the systematic analysis and optimization of the 58.com Android app’s startup process, covering profiling, componentized task framework, delayed initialization, merging launch and home activities, layout improvements, monitoring tools, and results that achieved roughly a 50% reduction in cold‑start time.
This article explains how to build a full‑tracking solution for Android by creating a Gradle plugin that registers a Transform, leveraging the Transform API and ASM bytecode instrumentation to automatically inject analytics code into click events and lifecycle callbacks, while covering the underlying concepts, implementation steps, and deployment process.
This article provides a step‑by‑step guide on compiling, deploying, and testing the Hardcoder server on Android, covering pre‑integration checks, property configuration, socket communication, JNI performance APIs, protobuf integration, build scripts, init scripts, and SELinux policies.
The Thor Container Framework, created by Baidu for its App to meet Hook technology needs, offers standardized Java and Native Hook interfaces through an abstract layer, enabling lightweight, dynamically delivered plugins with hot‑swap capability, cloud‑controlled activation, and robust disaster‑recovery features, supporting use cases such as low‑end optimization, privacy compliance, OOM handling, and pipeline integration.
This article introduces the role of OpenGL ES in mobile video editing, explains why it is preferred over Vulkan, details the rendering pipeline and GLSL shader programming, and provides step‑by‑step Android code for implementing image transition effects and combining multiple transitions.
This article explains the Java Service Provider Interface (SPI) mechanism, its core principles of decoupling and dynamic loading, walks through the ServiceLoader source code, and demonstrates how to apply SPI in both web and Android projects with Gradle configurations and sample modules.
The workflow extracts PAD assets from an AAB, builds a universal APK with bundletool, runs the legacy APK split pipeline, then reassembles a new AAB by merging the split base module with the saved PAD zip, preserving Play Asset Delivery for Google Play compliance.
Xiaohongshu refactored Android’s AsyncLayoutInflater by introducing a configurable thread‑pool, safe object pools, and a singleton ViewCache, eliminating ArrayMap and LayoutInflater lock issues, which together yielded over 20% faster cold‑starts and page loads, demonstrating significant performance and business benefits.
This article explains why user reach is essential for mobile apps and details practical implementations of SMS, push notifications, in‑app banners, and Android widgets, including configuration steps, common issues, and troubleshooting methods to improve delivery success and user experience.
This article introduces Google's recommended MVI (Model-View-Intent) architecture for Android, compares it with MVVM, explains the benefits of unidirectional data flow, and provides practical Kotlin implementations—including LiveData state handling, single-event management, and step-by-step code examples—to guide developers in adopting MVI in mobile projects.
This article examines the challenges of achieving view‑level background blur on Android, compares four implementation strategies—including open‑source libraries and custom AOSP modifications—analyzes their performance, compatibility, and visual quality, and provides code examples and practical recommendations for developers.
This article details Baidu's comprehensive approach to improving Android app launch performance by evaluating existing tracing tools, selecting Perfetto, developing a Gradle-based automatic instrumentation plugin, handling trace collection and analysis with Trace Processor, and implementing automated detection of regressions, lock contention, and method-level CPU and wall‑time degradations.
This article presents a comprehensive, high‑precision, stable, and full‑link event tracking solution for iOS, Android, and H5 clients, detailing the shortcomings of traditional point‑tracking, the design of objects and a virtual tree (VTree), AOP‑based click handling, exposure tracking via VTree diffs, performance optimizations, refer‑based link tracing, and integration with H5/RN, all validated in the NetEase Cloud Music ecosystem.
The paper presents a React Native‑based dynamic list solution that embeds an RN container inside Android RecyclerView ViewHolders, using data‑driven rendering and pre‑loaded offline bundles to achieve middle‑to‑upper performance, modest memory use, and sub‑0.01% error rates while preserving native first‑screen speed.
This article explains Android’s display pipeline—CPU, GPU, and Display—and dives deep into how the Choreographer registers callbacks, schedules traversals, processes Vsync signals, and coordinates rendering to achieve fluid UI updates.
TheRouter is a Kotlin‑based, full‑stack solution for Android modular development that provides page navigation, cross‑module dependency injection, automatic initialization, dynamic actions, and remote route table updates, offering extensive configuration, code‑free reflection, and tools for migration, debugging, and performance optimization.
This article investigates why upgrading the Feishu Android project's CI build environment from JDK 8 to JDK 11 caused a 50% increase in build time, analyzes JVM, Gradle, and Docker interactions, and presents concrete JVM flag and environment‑variable solutions that restored parallelism and reduced build duration back to pre‑upgrade levels.
This article explains how to build a high‑precision Android startup performance pipeline by selecting the right tracing tool, extending Perfetto with custom Gradle instrumentation, handling edge‑case trace mismatches, and using Trace Processor’s Python API for automated wall‑time and CPU‑time regression detection.
The article presents a comprehensive approach to Android game multi‑channel packaging, combining independent SDK modules with a unified proxy layer and an apktool‑based merge of manifests, resources, and smali code, automated through scripted Jenkins pipelines, which resolves dex limits, resource conflicts, and cuts packaging time from over an hour to roughly twenty minutes.
This article details a five‑month performance project that reduced the heart‑beat app’s average launch time from over eight seconds to around four seconds by dissecting cold‑start phases, optimizing Application initialization, streamlining the launch chain, and applying home‑page, lock, and monitoring strategies.
Alipay’s client engineering team details a comprehensive approach to monitoring, measuring, and improving time‑consuming user experiences—especially cold‑start—by employing video frame analysis, ActivityTaskManager, extensive instrumentation, home‑page snapshot techniques, temperature control, patch‑APK injection, AOP‑based diagnostics, and the Spider SDK within a robust APM platform.
This article explains how to use the open‑source Scrcpy tool to mirror an Android device onto an Ubuntu system, covering installation, required Android version, USB and wireless connections, screen configuration, recording, window options, input control, and file transfer commands.
This article provides a comprehensive overview of OkHttp, covering its overall request process, the role of the dispatcher, how application and network interceptors work, TCP connection reuse via the connection pool, idle‑connection cleanup, key advantages, and the design patterns employed in the framework.
This article details the design and implementation of a custom nested scrolling layout for the Lofter 7.1.0 personal homepage, covering the selection of Android coordinator components, the underlying NestedScrolling mechanism, step‑by‑step integration, code analysis, inertia handling, and animation management.
This article details Alipay's evolution from basic thread pools to a sophisticated, multi‑layered scheduling framework that balances UI responsiveness, task prioritization, and resource control across Android devices, while outlining the technical challenges and future directions of fine‑grained scheduling.
This article explains the fundamentals of TCP/UDP and HTTP, details OkHttp's interceptor chain and caching mechanisms, and demonstrates a generic offline‑upload solution using Kotlin reflection to persist and replay network calls when connectivity is restored.
This article explains the background, principles, and implementation steps for using Android's drawFunctor to inject custom OpenGL rendering into the RenderThread, including C++ and Java code, handling state preservation, view transformations, context loss, and performance benefits demonstrated by memory and CPU usage comparisons.
This article details how Xianyu’s engineering team analyzed and adapted Xiaomi’s MIUI long‑screenshot capability for Flutter list pages, covering the problem background, system source investigation, scroll view detection, event proxy design, asynchronous channel and synchronous FFI communication, and performance results.
The Shadow framework, developed by Tencent, is an open‑source Android plugin solution that reuses independent app source code, employs zero‑reflection dynamic loading, minimizes host footprint, and provides detailed module architecture, component support, Flutter integration, and isolation mechanisms for stable, dynamic plugin development.
By disabling Jetifier through a custom Gradle plugin, fully migrating all Support libraries to AndroidX, and adding CI guardrails to block legacy dependencies, the team cut Android Studio sync time by roughly two and a half minutes and improved incremental build speed by 28% without sacrificing build stability.
This article details Baidu's multi‑step Android APK resource‑size reduction strategy, covering the structure of APK resources, built‑in AAPT2 optimizations, custom path and filename shortening, resource‑name collapsing, sparse entry encoding, image compression, duplicate‑resource handling, and the impact of AAB and Jetpack Compose on overall package size.
This article examines SQLite's journal modes, Android's thread and connection‑pool configurations, and demonstrates through source‑code analysis that converting a database from the default rollback‑journal mode to write‑ahead logging (WAL) is safe and improves concurrency performance.
The article details Baidu App’s third‑stage Android APK size reduction, explaining the res/ and assets structure, reviewing AGP’s OptimizeResources, ShrinkResources and new flags, and describing a custom AAPT2‑based tool that shortens paths and filenames, removes extensions, collapses names, uses sparse encoding, integrates third‑party guards and image‑compression techniques to significantly shrink the package.
This article examines Android’s Binder inter‑process communication mechanism, detailing how SELinux integrates with the /dev/binder driver, the role of ServiceManager as ContextManager, the definition of binder‑related permissions, and the kernel‑level security hooks that enforce SEAndroid checks during binder transactions.
This article details a comprehensive, step‑by‑step approach to reducing Android APK size—including library pruning, resource compression, class file optimization, and automated monitoring—to keep app packages lightweight and prevent size regression over successive releases.
This guide walks through creating an Android e‑commerce live‑streaming app using Java and the Zego real‑time audio‑video SDK, covering SDK integration, room creation, token generation, stream publishing and playback, and essential security considerations, with code snippets and practical implementation steps.
Android APK digital signatures ensure app integrity and author authenticity by hashing files and signing with a private key, with four schemes—v1 (JAR‑style per‑file digests), v2 (whole‑APK block), v3 (key‑rotation support), and v4 (external .idsig for fast incremental installs)—each offering progressively stronger protection and installation speed.
This article provides an in‑depth guide to analyzing Android native crashes, explaining common SIGSEGV types, interpreting tombstone logs, extracting register and memory information, using coredumps, and employing tools such as GDB, lldb, ASAN, HWASAN, and assembly inspection to trace and resolve crash causes.
A middle‑aged Android developer recounts breaking his child's "Niu Ting Ting" device, then details how he recreated its functionality by integrating OpenCV‑based paper detection, OCR, and TTS into a mobile app, complete with code snippets and performance results.
This article discusses several frequent Android development challenges—including hiding the soft keyboard after activity finish, proper use of the merge tag, LinearLayout weight handling, and numerous Fragment lifecycle pitfalls—providing practical solutions, code snippets, and best‑practice recommendations to improve app stability and UI behavior.
This article examines Android Dex DebugInfo line‑number optimization, detailing the structure of DebugInfo, existing solutions, Baidu’s mapping‑based approach, R8 and Alipay techniques, and the resulting APK size reduction, while also describing the end‑to‑end pipeline for line‑number retracing in production.
The article explains why reducing APK size improves download conversion and performance, then details a systematic, divide‑and‑conquer approach for Baidu App that trims Dex, resources, native libraries and ZIP overhead using tools such as R8, AndResGuard, ByteX, Booster and AGP, achieving a reduction from roughly 123 MB to 115 MB with up to 6 MB saved per batch and outlining plans to open‑source the utilities.
The article explains Android’s user‑space locking hierarchy—from Java intrinsic and JUC locks to C++ std::mutex and pthread mutexes—detailing their internal structures, state transitions, and reliance on futex system calls for kernel‑level blocking, helping developers optimize synchronization across Java and native layers.
This article explains the fundamental concepts of Window, Insets, and WindowInsets in Android, describes the different inset types, demonstrates how to retrieve and apply them with modern AndroidX APIs, and provides practical Kotlin code examples for handling system UI elements such as status bars, navigation bars, and the soft keyboard.
This article analyzes JDHybrid's offline loading architecture for Android and iOS, detailing mechanisms such as direct file loading, request interception, WKURLSchemeHandler, package generation, download tiering, preloading strategies, memory warm‑up, debugging tools, and performance monitoring that together boost first‑screen speed and reduce bandwidth during high‑traffic events.
This guide shows how to repurpose an old Android phone into a functional web server by installing Termux, configuring SSH with Dropbear, setting a static IP, installing Ruby, Sinatra, Puma and nginx, enabling port forwarding, dynamic DNS, and performing basic load testing and security considerations.
This article explores the challenges of mobile white‑box testing and presents an AOP‑driven solution that injects flow‑recording and replay code suites into Android and iOS apps, detailing technical goals, testability metrics, instrumentation techniques, and practical engineering outcomes.
This article explains how to embed Jetpack Compose within an existing RecyclerView using ComposeView, examines the default DisposeOnDetachedFromWindow strategy, its impact on view recycling, and presents alternative composition strategies such as DisposeOnViewTreeLifecycleDestroyed and the newer pooling-aware strategy to improve performance.
This article examines the problem of growing APK sizes caused by R.java files in JD.com's Android pluginized client, analyzes the feasibility of R file slimming, and presents a Gradle Transform and ASM‑based solution that inlines resource IDs, removes R files, and achieves 3‑5% size reduction without noticeable build‑time impact.
This article explains why the Transform API is deprecated in AGP 7.0, introduces the new AsmClassVisitorFactory‑based API, compares code examples, discusses performance benefits and drawbacks, and provides guidance for migrating Android Gradle plugins to the newer variant and artifact system.
This guide demonstrates how to use Frida for Android reverse engineering, covering essential commands, stack tracing, and practical hook scripts for common methods such as HashMap.put, Base64.encodeToString, and UI event listeners, enabling developers to locate and analyze encryption logic within apps.
This article examines the complexity of the Bluetooth protocol stack, focusing on Android’s Host layer vulnerabilities, and provides detailed analyses of three critical CVEs—CVE‑2020‑27024 (SMP), CVE‑2021‑0918 (GATT), and CVE‑2021‑39805 (L2CAP)—including protocol overviews, code excerpts, and exploitation paths.
This tutorial demonstrates how to capture and reproduce the dynamic newSign parameter of the X‑Wu Android app by reverse‑engineering the request‑signing method with Frida, exposing it via an RPC server, and then using the generated signature to call the official search API.
