didi/DoKit

This system is a cross-platform debugging and development toolkit (DoKit/DoraemonKit) that provides a suite of diagnostic, monitoring, and testing utilities for iOS, Android, Flutter, and Web applications. It enables developers to inspect and modify application states, including network traffic, memory usage, UI hierarchy, and performance metrics, directly within the app. The toolkit supports multi-device control, automated testing, and environment simulation (such as GPS and weak network conditions) to facilitate comprehensive debugging and quality assurance workflows.

51 changes.

This period focused on significantly expanding the iOS SDK with new debugging tools, including memory leak detection, network interception, and performance monitoring. It also introduced comprehensive support for WeChat Mini Programs and added localization and dark mode compatibility across the platform.

45 changes.

This period focused on significantly expanding the DoraemonKit iOS toolkit with extensive performance, UI, and network debugging plugins, alongside the initial release of DoKit for Flutter. The work introduced new capabilities for monitoring app health, analyzing view hierarchies, and simulating network conditions, while also establishing a Swift demo application and Android build system improvements.

55 changes.

This period focused on expanding the DoKit debugging toolkit across Flutter, Web, Android, and iOS platforms. Significant additions include comprehensive APM and network monitoring for Flutter, a full-featured web debugging suite with console and network inspection, and new Android modules for memory leak detection and thread monitoring. The work also established a multi-device control feature for iOS and Android, alongside a no-op Android SDK for safer integration.

7 changes.

This period focused on expanding the toolkit's capabilities for remote device management and automated testing across iOS, Android, and Web platforms. Key additions included multi-device synchronization, automated UI testing infrastructure, and GPS simulation tools, alongside new JavaScript execution and toast notification components.

A new plugin named 'One-Machine-Multiple-Control' has been added to the web package. It provides a user interface for managing multiple connected devices, including a text area for entering a network address, buttons to connect/disconnect, start/stop recording, and view history records. The plugin also implements the core logic for intercepting and forwarding HTTP requests and responses via WebSocket to a host device, enabling synchronized control across multiple clients.

Web/packages/web/src/plugins/one-machine-with-multiple-controls · high confidence

Users can now view detailed information about Application Not Responding (ANR) events, including the crash content and duration, and export the report via a new detail screen.

iOS/DoraemonKit/Src/Core/Plugin/Performance/ANR/Detail · high confidence

Introduced the 'Data Mock' (api-mock) plugin, which intercepts web requests to simulate API responses. The plugin fetches interface configurations from the Dokit server, merges them with local storage state, and hooks into fetch and XHR requests to redirect them to mock endpoints. This allows users to toggle specific interfaces and scenes to simulate backend behavior during development.

Web/packages/web/src/plugins/api-mock · high confidence

A new 'Align Ruler' plugin has been added to the web package, introducing a crosshair-style ruler overlay that displays the cursor's position coordinates (top, right, bottom, left) and allows dragging to adjust the crosshair. The feature includes a dedicated Vue component for the ruler and info box, registered as an independent plugin.

Web/packages/web/src/plugins/align-ruler · high confidence

The Android/dokit-autotest module introduces a new automated testing feature for Android. This includes a new \DoKitAutotestActivity\ with fragments for connection management and main controls, along with \AutoTestControlKit\ and \AutoTestManager\ to handle recording, execution, and state management. The UI provides buttons to start/stop recording and testing, connect to a service, and view case lists, supported by new layout files, drawables, and string resources.

Android/dokit-autotest · high confidence

The Android demo application is initialized with essential configuration files (.editorconfig, .gitignore, proguard-rules) and a debug AndroidManifest.xml declaring required permissions for location and network access. The demo's Application class is updated to initialize DoKit with custom kits and network interceptors, and to configure Fresco. New utility classes for AMap integration (AMapUtil, ChString, DrivingRouteOverLay, RouteOverlay) and GPS mock functionality (FloatGpsPresetMockKit, FloatGpsPresetMockKitView, FloatGpsRouteKitView) are added to support location simulation and route overlay features.

Android · high confidence

The Android/dokit-util module introduces a comprehensive set of utility classes for Android development, including ActivityUtils for activity lifecycle and state management, BarUtils for status bar and navigation bar customization, AppUtils for application information and status checks, and various constant classes (CacheConstants, MemoryConstants, PermissionConstants, RegexConstants, TimeConstants) that provide standardized values and helper methods for common Android tasks such as screen adaptation, battery status monitoring, and app store integration.

Android/dokit-util · high confidence

Introduced a new App Info plugin that displays device and application information, including device name, model, OS version, screen size, IP addresses, bundle ID, and version numbers. The feature also exposes permissions for location, push, camera, audio, photo, address book, calendar, reminders, and Bluetooth, with support for custom app information via a block callback.

iOS/DoraemonKit/Src/Core/Plugin/Common/AppInfo · high confidence

Introduced a new iOS demo application, DoraemonLoadAnalyzeDemo, which serves as a testbed for the DoraemonLoadAnalyze framework. The demo project includes the necessary source files, Xcode project configuration, and a main entry point that invokes printLoadAnalyzeInfo() to output load time analysis information to the console, enabling developers to verify the framework's functionality.

iOS/DoraemonKit/Framework, iOS/DoraemonLoadAnalyzeDemo · high confidence

The DoraemonKit now includes two new performance monitoring plugins: an FPS (Frames Per Second) monitor that displays a real-time oscillogram of frame rates, and a Time Profiler that records and displays the execution time of Objective-C method calls, including call depth and cost filtering. These tools allow developers to easily identify performance bottlenecks and frame rate issues within the DoraemonKit interface.

iOS/DoraemonKit/Src/Core/Plugin/Performance/TimeProfiler · high confidence

Introduced a new File Sync plugin for iOS that enables file synchronization via a local web server. The plugin adds a \DoraemonFileSyncViewController\ that displays a banner, status label, and a toggle button to start or stop the GCDWebServer. When started, it displays the local IP and port for connection; when stopped, it halts the server. This provides a UI to manage file sync operations directly from the DoraemonKit interface.

iOS/DoraemonKit/Src/Core/Plugin/Platform/FileSync · high confidence

The DoraemonKit GPS module introduces three new UI views for mock GPS functionality: DoraemonMockGPSCenterView, DoraemonMockGPSInputView, and DoraemonMockGPSOperateView. These components provide the interface for entering and displaying mock GPS coordinates. The implementation includes support for iOS 13's dark mode, ensuring the UI adapts its background colors appropriately for both light and dark themes.

iOS/DoraemonKit/Src/GPS/View · high confidence

Introduced a new GPS plugin and its associated view controllers, enabling users to simulate GPS locations on iOS. The implementation includes a plugin entry point, a map-based interface for selecting coordinates, and logic to handle user authorization and mock data persistence.

iOS/DoraemonKit/Src/GPS · high confidence

Introduces a new iOS plugin, DoraemonMultiControlPlugin, which registers a 'Multi-Control' entry in the DoraemonKit platform tools menu. Tapping this entry opens the DoraemonMCViewController, providing the user interface for the multi-device control feature.

iOS/DoraemonKit/Src/MultiControl/Plugin · high confidence

Introduced a new NSUserDefaults plugin for DoraemonKit that provides a list of all user defaults, allowing users to search for specific keys and edit their values. The feature includes a main view controller for browsing and filtering, an edit view controller for modifying entries, and a model class to represent key-value pairs.

iOS/DoraemonKit/Src/Core/Plugin/Common/NSUserDefaults · high confidence

A new Network plugin has been introduced to the web package, providing a UI for inspecting HTTP traffic. The plugin registers a router plugin that listens for request lifecycle events (SEND, DONE, ERROR) and updates a global state. The UI, composed of main.vue and request-item.vue, displays a list of requests showing their URL, type, method, and status, and allows users to expand each item to view detailed information including query parameters, body content, headers, and raw response data.

Web/packages/web/src/plugins/network · high confidence

Introduced a new 'Scan QR code' plugin for DoKit for Web, allowing users to scan QR codes via the browser's camera. The feature includes a Vue component (\app.vue\) and a router plugin registration (\index.js\) that integrates the scanner into the DoKit interface, handling camera permissions and scan results.

Web · high confidence

A new Swift-based demo application (DoKitSwiftDemo) has been added to the iOS directory. This includes the full Xcode project structure, app delegate, and various view controllers demonstrating features such as logging, performance testing, network requests, GPS simulation, crash handling, and memory leak detection.

iOS/Swift · high confidence

A new iOS Demo project has been added, providing a Swift-based example application. This includes the core application entry point (AppDelegate) which initializes the DoraemonKit debugging tool, a basic ViewController, and the necessary configuration files (Info.plist) to support the demo environment.

iOS/Demo · high confidence

The DoraemonKit iOS plugin now includes a new UI profiling feature that visualizes the depth of the view hierarchy. When enabled via the 'UI层级' (UI Level) switch in the plugin's UI, the kit overlays a red border on the deepest view in the current view controller's hierarchy and displays the view class names and depth levels in a draggable, expandable window. This helps developers analyze and debug view controller structure and layout issues.

iOS/DoraemonKit/Src/Core/Plugin/Performance/UIProfile · high confidence

The VCProfiler plugin now instruments iOS view controllers and web views to track performance metrics. For view controllers, it swizzles initialization methods (initWithNibName, initWithCoder) and lifecycle methods (viewDidLoad, viewWillAppear, viewDidAppear, viewWillDisappear, viewDidDisappear) to record page entry and exit times via DoraemonHealthManager. For WKWebView, it swizzles loadRequest to track H5 page opening. A blacklist mechanism is also introduced to skip profiling for specific view controllers.

iOS/DoraemonKit/Src/Core/Plugin/Performance/VCProfiler · high confidence

Added a new example WeChat Mini Program project in the miniapp/example directory, including the main application entry (app.js), configuration (app.json, project.config.json), styles (app.wxss), and sitemap. This provides a baseline implementation for developers to reference when building mini-apps.

miniapp/example · high confidence

The DoraemonKit iOS SDK now includes a new Weex Info plugin that displays detailed Weex runtime information. This includes the Weex SDK version, JS library version, bundle type, bundle size, and various performance metrics such as download time, render time, and interaction times. The feature is implemented through a new \DoraemonWeexInfoPlugin\ that opens a \DoraemonWeexInfoViewController\ showing a list of Weex-related data points, with a header view for the bundle URL and a table view for the metrics. The \DoraemonWeexInfoDataManager\ singleton collects and stores the Weex information, while the \DoraemonWeexInfoAnalyzer\ processes the raw data. This allows users to inspect Weex-specific diagnostics and performance data within the DoraemonKit interface.

iOS/DoraemonKit/Src/Weex/Info · high confidence

Introduced a new DoraemonWeexStorageResolver component that reads Weex storage data from a plist file located in the app's Documents directory. This adds a specific utility for resolving and retrieving Weex storage information within the iOS DoraemonKit framework.

iOS/DoraemonKit/Src/Weex/Storage/Function · high confidence

Introduced a new startup performance plugin that measures and displays the app's launch time. The \DoraemonStartTimePlugin\ registers a view controller that allows users to toggle the startup time measurement and view the total startup duration. Additionally, a detailed time profiler view controller was added to display and export the startup cost details, providing deeper insight into the application's cold start performance.

iOS/DoraemonKit/Src/Core/Plugin/Performance/StartTime · high confidence

Introduced two new plugins in the web package: an 'app-info' plugin that displays device and page metadata (user agent, URL, screen dimensions, etc.) via a Vue component, and a 'demo' plugin that renders a simple 'Hello Dokit' message. Both are registered as RouterPlugins, making them available within the application's plugin system.

Web/packages/web/src/plugins/app-info · high confidence

Introduced a new BizKitManager singleton that allows registering and managing business kits (BizKit) by group. The manager provides methods to build, add, and retrieve kits, enabling a custom entry point for business modules within the Flutter application.

Flutter/lib/kit/biz · high confidence

The DoKit entry point now supports a \useRunZoned\ parameter, allowing users to disable the forced use of \runZonedGuarded\ to avoid conflicts with existing zones. Additionally, the SDK exposes new methods for managing BizKit instances, including \updateKitGroupTip\, \addKit\, \addBizKits\, \newBizKit\, and \buildBizKit\, providing a public API for registering and configuring kits.

Flutter/lib · high confidence

A new \DoraemonCopyLabel\ UI component has been introduced, extending \UILabel\ to support copying its text to the system clipboard. Users can now long-press the label to trigger a context menu with a 'copy' action, enabling convenient text copying directly from the UI.

iOS/DoraemonKit/Src/Core/CommonUI/Label · high confidence

The DoraemonKit iOS core now includes new utility categories: Foundation+Doraemon provides a readable description for NSDictionary, NSArray, and NSSet that attempts to parse and display JSON data and strings; NSObject+Doraemon adds safe method-swizzling helpers; UIColor+Doraemon adds color utilities including hex parsing and iOS 13 dark-mode-aware colors; UIImage+Doraemon adds image loading from xcassets, scaling, and color-based image generation; UIView+Doraemon adds convenient frame/size/center properties and view-hierarchy helpers; UIViewController+Doraemon adds safe-area and top/root view-controller helpers. These changes improve debugging, layout, and theming capabilities within the kit.

iOS/DoraemonKit/Src/Core/Category · high confidence

Introduces a new 'Element View' feature that allows users to inspect the DOM tree, view element attributes, and see computed styles. The update adds several new Vue components (ElementAttributes, ElementBoxModel, ElementBreadcrumb, ElementComputedStyle, ElementStyles, ElementTree) and their container (elementContainer) to display detailed information about selected elements, including their CSS properties, box model, and style rules.

Web/packages/web/src/plugins/element · high confidence

The DoraemonKit iOS plugin now exposes a local HTTP server (port 9002) to handle file and database operations. New endpoints allow users to retrieve device information, list and download files, upload and save files, create folders, and perform SQL-like operations (insert, update, delete, get) on local tables. This enables remote debugging and management of device files and app data through the DoraemonKit interface.

iOS/DoraemonKit/Src/Core/Plugin/Platform/FileSync/Function · high confidence

A new iOS Demo project has been added, including the Xcode project file (project.pbxproj) and the associated Xcode scheme (Demo.xcscheme). This establishes the build configuration for the Demo application, linking source files like AppDelegate and ViewController, and integrating CocoaPods dependencies.

iOS/Demo.xcodeproj · high confidence

The MLeaksFinder module is added to the iOS DoraemonKit, introducing a new memory leak detection feature. This includes a suite of Objective-C categories (e.g., \NSObject+MemoryLeak\, \UIViewController+MemoryLeak\, \UIView+MemoryLeak\) that swizzle UIKit methods to track object lifecycles. The implementation uses a proxy pattern (\MLeakedObjectProxy\) to monitor for potential leaks and, if enabled, integrates with \FBRetainCycleDetector\ to identify retain cycles. This allows users to identify and debug memory leaks within the application.

iOS/DoraemonKit/Src/MLeaksFinder/Function · high confidence

The DoraemonKit iOS module now includes a new user interface for the 'one device, multiple control' feature. A new \DoraemonMCViewController\ has been added to manage the UI for connecting to a multi-control server, handling both WebSocket connections via IP address input or QR code scanning, and switching between master and slave modes.

iOS/DoraemonKit/Src/MultiControl/UserInterface · high confidence

Introduced new debugging capabilities for iOS, including CPU and memory usage monitoring with real-time oscillograms, ANR (Application Not Responding) detection with history and clearing options, and a UI hierarchy viewer. These plugins allow users to toggle monitoring, view live metrics, and inspect the view hierarchy directly within the DoraemonKit interface.

(repo-wide) · high confidence

A new database debugging interface has been added to the iOS DoraemonKit. Users can now toggle a local debug server (port 9002) directly from the app to inspect database states, with UI controls to start/stop the service and view status messages.

iOS/DoraemonKit/Src/Database · high confidence

The DoraemonKit iOS module introduces new UI components for the memory leak finder feature. A dedicated list view controller (DoraemonMLeaksFinderListViewController) and its corresponding table view cell (DoraemonMLeaksFinderListCell) have been added. These files implement the display of memory leak results in a scrollable list, allowing users to view detected leaks and navigate to a detail view.

iOS/DoraemonKit/Src/MLeaksFinder/List · high confidence

A new 'Method Use Time' plugin has been added to DoraemonKit, providing a toggle to enable or disable the tracking of method execution times. Users can also navigate to a list view to review the collected performance data. This feature is implemented as a standalone plugin within the iOS SDK.

iOS/DoraemonKit/Src/MethodUseTime · high confidence

Introduces a new pthread hook kit that enables thread monitoring and debugging on Android. The change adds a new kit (PThreadKit) that hooks into pthreads to capture thread information, including Java and native stack traces, thread counts, and thread names. It provides a UI (PThreadHookUiActivity) to display this information in a RecyclerView, and includes helper classes (AutoDumpListener, PThreadDumpHelper) to automatically dump thread data when thresholds are exceeded. The feature is registered as an inner kit within the Dokit framework.

Android/dokit-pthread-hook · high confidence

Introduces two new shared UI components in the web package: a generic Card component for consistent card-style containers with a title and body, and an InfoCard component that displays key-value pairs with filtering, clearing, and refreshing capabilities.

Web/packages/web/src/common · high confidence

The sandbox browser plugin now supports opening SQLite database files (with any suffix) and WebP images. Users can browse the device's sandbox, view database tables and data via a new DB viewer, and preview WebP images. The change also includes a fix for UserDefaults search.

iOS/DoraemonKit/Src/Core/Plugin/Common/Sanbox · high confidence

A new 'Static Resources' plugin has been added to the web dashboard, providing a UI to inspect and view details of web resources (CSS, scripts, images). The feature includes a tabbed interface to filter resources by type, a list view showing resource entries, and an expandable detail view that displays image thumbnails or code content. The implementation registers the plugin via \@dokit/web-core\, defines resource type mappings and utility functions for fetching and processing resource data, and introduces new CSS variables for styling the resource inspection components.

Web/packages/web/src/plugins/resources · high confidence

A new toast notification component has been added to the core package, providing a simple way to display temporary messages to users. The component renders a centered, semi-transparent overlay with a fade-in and fade-out transition, displaying a message for a configurable duration (defaulting to 3 seconds). It is registered as a global property ($toast) on the Vue instance, allowing easy invocation throughout the application.

Web/packages/core/src/common/components/toast · high confidence

Introduced a new ViewMetrics plugin for iOS that adds a toggleable border overlay to all views in the application. The implementation includes a configuration singleton (DoraemonViewMetricsConfig) to manage border color, width, and enabled state, and extends UIView to recursively apply or remove a colored border layer on layout changes. This feature allows users to visualize the layout structure of the app's UI elements.

iOS/DoraemonKit/Src/Core/Plugin/UI/ViewMetrics · high confidence

The DoraemonKit iOS plugin now includes a new DoraemonWeakNetworkWindow that displays real-time uplink and downlink flow data in a draggable overlay. The window adapts its root view controller based on the iOS version: it uses a standard view controller for iOS 10+, but explicitly instantiates a DoraemonStatusBarViewController for iOS 9.0+ to ensure the status bar is correctly displayed. The UI updates flow values on the main thread and formats large byte values into kilobytes.

iOS/DoraemonKit/Src/Core/Plugin/Performance/WeakNetwork/View/Window · high confidence

Introduces a new web console plugin that intercepts and displays browser console logs (log, info, warn, error) in a dedicated UI tab. The feature includes a tabbed interface to filter logs by type, a scrollable list of captured log entries with expandable details for objects and arrays, and a command execution input that evaluates JavaScript in the browser context. The plugin registers itself as a router plugin, overrides the native console methods to capture logs, and restores the original console behavior when unloaded.

Web/packages/web/src/plugins/console · high confidence

The core package introduces a new event recording and playback system for the web environment. A new \EventRecorder\ class monitors DOM interactions (clicks, touches, input, scroll) and logs them, while a new \EventPlayback\ class replays these events via WebSocket messages, supporting both manual and automated test modes. Supporting utilities include a \UIController\ for visual selection overlays, a \Socket\ wrapper for WebSocket management, and helper modules for node text extraction, CSS/XPath finding, and action mapping.

Web/packages/core/src/common/js · high confidence

A new 'web-vitals-time' plugin has been added to the web package, introducing a 'Performance Metrics' feature that displays key web vitals (LCP, CLS, FID, TTFB) and page load timing details. The plugin registers a router plugin that renders an info-box component, which uses the 'web-vitals' library to collect and display performance data, including a fallback to 'LOADED' time for iOS compatibility.

Web/packages/web/src/plugins/web-vitals-time · high confidence

The DoraemonKit iOS plugin now includes a dedicated view controller and table view cell for displaying a list of ANR (Application Not Responding) crash logs. Users can browse, sort by creation time, and delete these logs directly from the UI, with the ability to tap into individual files for detailed inspection.

iOS/DoraemonKit/Src/Core/Plugin/Performance/ANR/List · high confidence

The DoraemonKit now includes a new \DoraemonCocoaLumberjackLogger\ component that bridges the CocoaLumberjack logging framework to the DoraemonKit logger system. This change introduces new header and implementation files (\DoraemonCocoaLumberjackLogger.h/m\ and \DoraemonDDLogMessage.h/m\) to capture and store log messages, enabling features such as one-click export and single-line copying of logs.

iOS/DoraemonKit/Src/Logger/Function · medium confidence

Added a new plugin for the CocoaLumberjack logging framework, including the plugin implementation and a dedicated settings view. The new UI provides a toggle switch to enable or disable the logger without restarting the app, and a button to view the log records.

iOS/DoraemonKit/Src/Logger · high confidence

The dokit-ui package now includes new \DoCol\ and \DoRow\ components for web-side layout. \DoRow\ supports flexbox-based grid layouts with configurable gutter, alignment, and justification. \DoCol\ provides a 24-column grid system with responsive breakpoints (xs, sm, md, lg, xl) and offset/push/pull utilities. These components are registered globally in the dokit-ui index.

Web/packages/core/src/common/components/dokit-ui · high confidence

Added new Android source files to support GPS location simulation and memory leak detection. The change introduces \BinderHookHandler\ and \CustomDialogFragment\ in the \dokit-gps-mock\ module to handle GPS hooking and UI. Additionally, multiple files from the \dokit-leakcanary\ module are added, including \ABridgeService\ for inter-process communication, and core LeakCanary classes (\ActivityRefWatcher\, \AnalysisResult\, \AndroidWatchExecutor\, \HeapAnalyzer\, \HeapDump\, \InstrumentationLeakDetector\, \LeakTrace\, \LeakTraceElement\, \RefWatcher\) to enable memory leak detection and analysis capabilities within DoKit.

. · high confidence

The DoKit Web playground is now available for local development and testing. This includes new HTML pages (independent.html, index.html, index2.html, index3.html) that serve as test environments for the DoKit Web SDK, featuring multi-control capabilities, live reload functionality, and integration with external APIs. A dedicated development server script (dev-playground.js) has been added to serve these files and enable hot-reloading during development.

Web/playground · high confidence

New engine files (dokit\_binding.dart, dokit\_http.dart) were added to the Flutter/lib/engine directory. These introduce a custom WidgetsBinding and BinaryMessenger wrapper to intercept and log MethodChannel calls, alongside an HttpOverrides implementation to capture HTTP client metrics. This adds the underlying infrastructure for monitoring network and platform channel activity within the DoKit toolkit.

Flutter/lib/engine · high confidence

A new utility class, DoraemonToastUtil, has been added to the iOS/DoraemonKit/Src/Core/CommonUI/Toast directory. This class provides methods to display temporary toast notifications on the screen. The implementation includes support for iOS 13 dark mode by conditionally using system colors (labelColor) on iOS 13+ while falling back to black for earlier versions. It offers two display modes: a standard light-mode toast and a black-background toast with rounded corners, both of which automatically dismiss after 1.5 seconds.

iOS/DoraemonKit/Src/Core/CommonUI/Toast · high confidence

Introduced new \CLLocationManager+Doraemon\ and \DoraemonGPSMocker\ classes to enable GPS location mocking. The \CLLocationManager\ category adds a method to swizzle the location delegate, while the \DoraemonGPSMocker\ singleton manages the mock state, intercepts location updates, and forwards them to registered delegates. This allows the DoraemonKit tool to simulate location changes for testing or debugging purposes.

iOS/DoraemonKit/Src/GPS/Function · high confidence

Introduced a new 'H5 Door' plugin that provides a user interface for entering and navigating to target URLs. The feature includes a text input for direct URL entry, a quick-edit mode for constructing URLs with query parameters, and a local storage-backed history list that allows users to revisit or delete previous destinations.

Web/packages/web/src/plugins/h5-door · high confidence

Introduced new internal components for the Dokit Flutter kit: a generic storage interface (IStorage) with a bounded queue implementation (CommonStorage) for managing information objects, and a navigator observer (DokitNavigatorObserver) that forwards Flutter route lifecycle events (push, pop, remove, replace, user gestures) to internal observers for analytics or monitoring purposes.

Flutter/lib/kit · high confidence

Users can now access a dedicated memory leak detection interface within the DoraemonKit settings. This new plugin provides controls to toggle memory leak detection, enable alert pop-ups for detected leaks, and view a history of leak records, allowing developers to monitor and manage memory issues directly from the UI.

iOS/DoraemonKit/Src/MLeaksFinder · high confidence

Introduced a new DoraemonMethodUseTimeManager to track and analyze method execution times. The manager provides a toggle for enabling method use time tracking and exposes two distinct data views: a sorted list of load models by cost for general analysis, and a simplified array of class names with their execution times specifically for app health checks.

iOS/DoraemonKit/Src/MethodUseTime/Function · medium confidence

A new 'Storage' plugin has been introduced in the web package, providing a dedicated interface for managing browser storage. The feature includes a main view that aggregates three sub-components: 'localStorage', 'sessionStorage', and 'Cookie'. Each sub-component renders an 'InfoCard' displaying the respective storage contents, allowing users to view, filter, clear, or remove individual items. The implementation includes utility functions in \js/storage.js\ to handle the underlying browser APIs (e.g., overriding \localStorage\ methods to track changes) and direct cookie manipulation.

Web/packages/web/src/plugins/storage · high confidence

Introduced new UI views for the Health plugin, including a footer view, home view, background view, button view, starting title view, instructions cell and view, and a countdown window. Additionally, added the ViewAlign plugin and its associated manager and view classes to support UI alignment debugging.

iOS/DoraemonKit/Src/Core/Plugin/Platform/Health/View, iOS/DoraemonKit/Src/Core/Plugin/UI/ViewAlign · high confidence

Introduced a new set of Objective-C categories and helper classes to support UI hierarchy inspection. This includes \NSObject+DoraemonHierarchy\ and \UIViewController+DoraemonHierarchy\ for retrieving object properties and managing UI alerts, \UIColor+DoraemonHierarchy\ for color description, \DoraemonEnumDescription\ for human-readable enum values, \DoraemonHierarchyFormatterTool\ for formatting values, and \DoraemonHierarchyHelper\ for window traversal. These components provide the foundational logic for displaying and editing UI hierarchy information.

iOS/DoraemonKit/Src/Core/Plugin/UI/Hierarchy/Function · high confidence

Introduced a new ViewCheck plugin that allows users to tap on UI elements to inspect their properties, such as class name, instance variable names, position, size, and styling details like background and text colors. This feature enhances debugging by providing detailed visual information about the selected view hierarchy.

iOS/DoraemonKit/Src/Core/Plugin/UI/ViewCheck · high confidence

Introduced a new Weex DevTool plugin (DoraemonWeexDevTooloPlugin) and its associated view controller (DoraemonWeexDevToolViewController) that implements a QR code scanning interface for Weex development tools. The plugin checks for simulator environments and displays a toast message if scanning is unsupported, otherwise it opens the scanner view controller which handles URL parsing and launches the Weex DevTool debug interface.

iOS/DoraemonKit/Src/Weex/DevTool · high confidence

Introduced new debugging capabilities for Weex applications within the DoraemonKit iOS SDK. A new Weex Log plugin has been added, providing a dedicated interface to view, search, and filter Weex logs by level (Debug, Log, Info, Warning, Error). Additionally, a Weex Storage plugin was introduced, allowing users to inspect and view cached storage data directly through the DoraemonKit interface.

iOS/DoraemonKit/Src/Weex/Log, iOS/DoraemonKit/Src/Weex/Storage · high confidence

Introduced DoraemonWeexLogger and DoraemonWeexLogDataSource to capture and store Weex JavaScript logs. The logger registers with the Weex SDK to intercept log messages, filters for 'jsLog' entries, and stores them in a circular buffer (max 500 items) for later display.

iOS/DoraemonKit/Src/Weex/Log/Function · high confidence

Users can now view and filter Weex logs within the DoraemonKit toolset. This change introduces a new log viewing interface that includes a search bar for filtering logs by keyword, a segmented control for filtering by log level (Debug, Log, Info, Warn, Error), and a list view to display the log entries with expandable details.

iOS/DoraemonKit/Src/Weex/Log/View · high confidence

Introduced a new automated testing module within the Android/dokit-test package. This includes a test mode manager to switch between host and client modes, event monitoring for accessibility and lifecycle events, and processors to simulate user interactions like clicks, scrolls, and text changes. The module also supports custom events and TCP message handling, enabling remote control and data collection for UI testing.

Android/dokit-test · high confidence

Introduced a new backtrace logging utility, DoraemonBacktraceLogger, which provides methods to capture and format stack traces for the current thread, main thread, and all active threads. This addition enables developers to easily log detailed backtraces for debugging purposes.

iOS/DoraemonKit/Src/Core/Util/BSBacktraceLogger · high confidence

The utils package now includes a Rollup build configuration that compiles src/index.js into dist/index.js as an ES module, utilizing commonjs and terser plugins for production builds, alongside a README template for the package.

Web/packages/utils · medium confidence

Introduced two new visual debugging capabilities: a color picker that allows users to select colors from the screen, and a view checker that displays information about widgets under the cursor. These features are implemented in new files (color\_pick.dart, view\_check.dart) and registered in the visual kit manager.

Flutter/lib/kit/visual · high confidence

The DoraemonKit iOS plugin now includes a new ColorPick feature, introducing a color picker interface. This includes a magnifying glass layer for precise color sampling, an info window displaying the selected color's hex code, and a draggable window for user interaction. The implementation supports iOS 13+ dark mode by dynamically adjusting UI colors and images based on the user interface style.

iOS/DoraemonKit/Src/Core/Plugin/UI/ColorPick · high confidence

Introduced three new reusable Vue components in the core package: a 'card' component for displaying lists of items with icons and titles, a 'top-bar' component providing a header with a back button and title, and a 'version' component that displays the current application version alongside an icon. These components establish the foundational visual elements for the web interface.

Web/packages/core/src/common/components · high confidence

Users can now enable or disable crash log collection via a new toggle in the Doraemon settings. The app provides a dedicated interface to view, preview, and share collected crash logs, and allows users to clear all stored crash data. Under the hood, the app now registers custom handlers for uncaught exceptions and critical signal exceptions (such as SIGSEGV, SIGABRT, etc.) to capture detailed stack traces and save them to the device's cache directory.

iOS/DoraemonKit/Src/Core/Plugin/Performance/Crash · high confidence

The DoraemonKit now includes a custom implementation of the fishhook library (doraemon\_fishhook.c/h) to handle symbol rebinding. This change introduces a dedicated mechanism for intercepting and replacing function pointers at runtime, which is essential for the kit's hotfix and debugging capabilities. The implementation includes specific handling for memory protection (vm\_protect) to ensure safe modification of read-only sections, addressing potential crashes related to shared library const data copy memory pages.

iOS/DoraemonKit/Src/Core/Util/fishhook · high confidence

Introduced a new 'File Transfer' (FT) module for Android that enables remote file management via a local HTTP server. This includes a UI fragment, routing, and action handlers for operations such as listing files, uploading, downloading, creating, deleting, and renaming files, as well as querying and modifying SQLite databases. The module also registers as an inner kit and provides an ability processor for module initialization. Additionally, a new 'okhttp-v4' module was added to provide a wrapper for OkHttp v4 API calls.

Android/dokit-ft, Android/dokit-okhttp-v4 · high confidence

The iOS demo application now includes its initial user interface files. A new LaunchScreen.storyboard defines the app's launch screen, while a new Main.storyboard establishes the primary view controller for the demo project, enabling the application to run with a basic UI structure.

iOS/Demo/Base.lproj · high confidence

A new iOS plugin, DoraemonDeleteLocalDataPlugin, has been introduced to provide a user interface for clearing local data. The plugin registers a view controller that displays the current size of the app's home directory and, upon user confirmation, calls DoraemonUtil to clear local data, updating the UI to show a processing state during the operation.

iOS/DoraemonKit/Src/Core/Plugin/Common/DeleteLocalData · high confidence

A new \DoraemonBuriedPointManager\ component has been introduced to collect and report usage events. The manager aggregates event names and timestamps, automatically uploading them to the Doraemon analytics endpoint when the app enters the background, when more than 10 events are queued, or when 60 seconds have passed since the last upload. This enables basic telemetry for the DoraemonKit framework.

iOS/DoraemonKit/Src/Core/Util/BuriedPoint · high confidence

Introduced a new 'Large Image Detection' plugin for iOS that monitors and identifies large images loaded via SDWebImage. The feature includes a manager to track image data and size, a toggle in the DoraemonKit UI to enable or disable detection, and a list view to display detected large images with their URLs and sizes. The implementation uses method swizzling on UIImageView to intercept image loading, allowing the tool to overlay text on images exceeding a configurable size threshold.

iOS/DoraemonKit/Src/Core/Plugin/Performance/LargeImageDetection · high confidence

Introduced the DoraemonMemoryLeakData class to collect and manage memory leak information. This new component gathers details about detected leaks—including class name, object pointer, view stack, and retain cycle data—and provides a block-based callback mechanism for consumers to receive leak reports. The implementation leverages FBRetainCycleDetector to identify retain cycles when the internal flag is enabled, and forwards the collected leak data to the DoraemonHealthManager for further processing.

iOS/DoraemonKit/Src/MLeaksFinder/Function/Extra · high confidence

A new detail view controller for the MLeaksFinder feature has been introduced, displaying memory leak information via a scrollable label. This component allows users to view detailed descriptions of detected memory leaks within the DoraemonKit interface.

iOS/DoraemonKit/Src/MLeaksFinder/Detail · high confidence

A new list view has been added to the iOS DoraemonKit to display method execution time statistics. This includes a dedicated view controller and table view cell that render a list of methods sorted by their load time, allowing users to analyze performance metrics directly within the SDK.

iOS/DoraemonKit/Src/MethodUseTime/List · high confidence

The miniapp/dist directory now includes several new debug components: an App Information panel that displays system, account, user, and authorization details; an HTTP Injector for intercepting and modifying network requests; a Log Viewer for filtering and searching console logs; and a Page Door for simulating page navigation with dynamic parameters. These tools are integrated into the main debug interface, providing developers with immediate access to app state, network behavior, and navigation flows.

miniapp/dist · high confidence

The miniapp/example/pages directory now includes new example pages for displaying user information and viewing startup logs. The index page allows users to retrieve and display user profile data, make HTTP requests to external APIs (including a mock service), and interact with a custom 'dokit' component. The logs page provides a list of startup logs formatted with timestamps. These pages demonstrate miniapp initialization, API mocking, and component usage.

miniapp/example/pages · high confidence

The iOS DoKit module now supports multi-device control, allowing a master device to synchronize network requests and events to slave devices. This is implemented via a new \DKMultiControlProtocol\ and \DKMultiControlStreamManager\ to manage the master/slave state and WebSocket/TCP communication. Additionally, the toolkit now includes an event synthesis system (\UITouch+DKEventSynthesize\, \UIView+EventSynthesize\) that allows developers to programmatically generate and send simulated touch and gesture events (taps, long presses, drags, pinches) to the application's UI.

iOS/DoKit · high confidence

The DoraemonKit iOS SDK now includes a new network interception layer located in the \Interceptor\ directory. This introduces a \DoraemonNSURLProtocol\ that intercepts \NSURLSession\ requests, enabling features such as network flow monitoring, data caching, and mock domain customization. Additionally, the update adds support for simulating weak network conditions (including breaking connections, timeouts, and speed limiting) and handles threading issues for UI updates during network operations.

iOS/DoraemonKit/Src/Core/Network · high confidence

The DoraemonKit library introduces new charting components, specifically DoraemonBarChart and DoraemonPieChart, which replace the previous PNChart dependency. These components provide native iOS drawing for bar and pie charts. The implementation includes support for iOS 13 dark mode, utilizing system colors like secondarySystemBackgroundColor and labelColor to adapt to the user's interface style, while maintaining compatibility with older iOS versions.

iOS/DoraemonKit/Src/Core/CommonUI/Charts · high confidence

Added ScanerComponent.vue, a new Vue component that enables QR code scanning via the device camera, and introduced supporting components: ToolHelloWorld.vue as a demo plugin, and ToolsContainer.vue which provides a tabbed interface for tools like Console, AppInfo, and HelloWorld. These components are part of the Dokit web integration, allowing users to scan QR codes and access built-in diagnostic tools through a unified UI.

Web/packages/web/src/components · high confidence

Introduced a no-op (no-operation) stub implementation of the DoKit Android SDK. This module provides empty implementations for the core DoKit APIs, including the main entry points (DoKit, DoraemonKit), kit management (AbstractKit, IKit), floating window management (AbsDokitView, DokitViewManager), and various utility classes (NetworkRecord, PerformanceValueListener). This allows developers to include the DoKit dependency in their build configuration without enabling the actual debugging and monitoring features, effectively disabling the toolkit's functionality at runtime.

Android/dokit-no-op · high confidence

Introduced a new APM kit for tracking page launch performance. The change adds a route observer to measure the time taken for page transitions and displays a draggable overlay showing the previous page, new page, and cost time in milliseconds. Users can enable or disable this monitoring via a toggle in the APM kit interface, which inserts an overlay entry to display the time counter.

Flutter/lib/kit/apm/launch · high confidence

Users can now interact with a new standalone plugin demo, which includes an FPS monitor and a basic demo component, both featuring draggable behavior and the ability to be removed independently.

Web/packages/web/src/plugins/demo-single-plugin · high confidence

New utility files were added to the Flutter lib/util directory: byte\_util.dart provides a function to format byte counts into human-readable strings (B, K, M); screen\_util.dart introduces a singleton class to expose screen dimensions, density, and status bar heights via the Flutter MediaQuery; and time\_util.dart adds a helper to format epoch timestamps using the date\_format library.

Flutter/lib/util · high confidence

The web package now includes new utility modules in the assets directory: CssStore.js provides methods to retrieve computed styles and matched CSS rules for DOM elements; deepClone.js implements a robust deep clone function that handles complex types like Maps, Sets, Functions, and circular references; and util.js adds helper functions for data type detection, object stringification, GUID/UUID generation, event bus, and device detection. These utilities support internal web-side features such as element inspection and data manipulation.

Web/packages/web/src/assets · high confidence

Introduced a new iOS plugin that simulates poor network conditions. The change adds the \DoraemonWeakNetworkPlugin\ and its associated controller, manager, and handle classes, enabling users to toggle a 'weak network mode' via a switch in the Doraemon UI. When enabled, the plugin intercepts network requests and throttles data flow (uplink/downlink speed and delay) to simulate unstable or slow network environments for testing purposes.

iOS/DoraemonKit/Src/Core/Plugin/Performance/WeakNetwork/Function · high confidence

Added a suite of new utility functions and hooks to the web package, including a deep clone implementation, an MD5 hash utility, an event emitter class, and a network request wrapper that hooks into XMLHttpRequest and fetch to support multi-control scenarios. Additionally, a v-dragable directive was added to allow elements to be dragged and have their position cached in local storage.

Web/packages/utils/src · high confidence

Introduced new Flutter UI components for inspecting the widget build chain and widget details. The widget\_build\_chain\_page.dart file adds a controller and page that display a list of widgets in the build chain with search and filtering capabilities. The widget\_details\_page.dart file adds a new view that presents the widget overview and render object details, including horizontal scrolling support for the details page.

_Flutter/lib/widget/widget\_build\chain · high confidence

The DoraemonKit iOS module now supports English and Simplified Chinese interfaces. Users will see translated text for tool categories (e.g., 'Customize', 'Performance'), feature labels (e.g., 'Health Check', 'Mock Data'), and status messages across the kit's various debugging and monitoring screens.

iOS/DoraemonKit/Resource/en.lproj · high confidence

The DoraemonKit iOS SDK now includes new utility classes to support internal features: DoraemonNetworkUtil provides a thread-safe, singleton-based HTTP client for GET, POST, and PATCH requests with JSON serialization and HTTPS handling; DoraemonStatisticsUtil collects and uploads anonymous usage data (app ID, name, version, language) to a remote endpoint; DoraemonThreadSafeMutableArray and DoraemonThreadSafeMutableDictionary offer thread-safe alternatives to standard mutable collections using recursive pthread mutexes; and Doraemoni18NUtil provides localized string lookup for internationalization. These utilities enable the SDK to perform network operations, track usage, manage state safely across threads, and support multiple languages.

iOS/DoraemonKit/Src/Core/Util · high confidence

The DoraemonKit now uses a dedicated \DoraemonCacheManager\ singleton to persist user preferences and state for all internal tools. This includes toggle states for features like FPS, CPU, memory, and network monitoring, as well as configuration for mock GPS coordinates, crash logs, and H5/JS script history. By centralizing these switches and records, the app ensures that tool states (e.g., enabling memory leak detection or H5 history sorting) are preserved across app restarts.

iOS/DoraemonKit/Src/Core/Cache · high confidence

The DoKit Android plugin has been refactored to use a new configuration model with dedicated extension classes (DoKitExtension, GpsExtension, NetworkExtension, BigImageExtension, etc.) that allow granular control over features like GPS mocking, network interception, and slow method detection. The plugin now registers multiple transform tasks to handle different aspects of the application, including class transformation for various libraries (OkHttp, Glide, etc.) and stack-based method tracing. This change improves the plugin's modularity and configurability, allowing users to enable or disable specific debugging features more precisely.

Android/dokit-plugin · high confidence

The DoKit Android build plugin has been refactored, introducing a new DSL-based configuration model via extension classes (DoKitExtension, GpsExtension, NetworkExtension, BigImageExtension, SlowMethodExtension, WebViewExtension) that allow users to enable or disable specific debugging features like GPS mocking, network monitoring, and slow method detection. The plugin now registers multiple dependent transforms for stack-based slow method detection, supporting a configurable call depth (defaulting to 5 levels). Additionally, the plugin includes logic to parse the AndroidManifest.xml to identify application components and third-party libraries, and integrates with the Android Gradle Plugin (AGP) 7.0+ via the new Variant API (DoKitCommonTransformV34) while maintaining backward compatibility for older AGP versions.

Android/buildSrc · high confidence

The miniapp directory is initialized with the DoKit debugging SDK for WeChat mini-programs, including a Babel configuration, a Gulp build pipeline (handling styles, scripts, and assets), and PostCSS configuration. This adds the core SDK structure and build automation for the miniapp component.

miniapp · high confidence

The DoraemonKit SDK introduces a comprehensive \DoraemonManagerPluginType\ enumeration that explicitly lists all supported debugging tools, including performance monitors (FPS, CPU, memory, network flow, ANR, startup time, large image detection, and UI hierarchy), visual tools (color picker, view metrics, alignment guides), platform tools (mock data, health check, file sync), and utility plugins (NSLog, CocoaLumberjack, database, NSUserDefaults, JS scripts). The \DoraemonManager\ class now exposes methods to add, remove, and manage these plugins by type or name, and supports custom initialization via mock domains, starting positions, and callback blocks for H5 doors, ANR events, and performance data.

iOS/DoraemonKit/Src/Core/Manager · high confidence

The GPS mock module now supports simulating movement along a route (trajectory simulation) and random drift, with support for speed updates. It also includes utilities for converting between WGS84, GCJ-02, and BD-09 coordinate systems, and hooks into location services to intercept and modify location updates for third-party map SDKs (Amap, Baidu, Tencent, etc.).

Android/dokit-gps-mock · high confidence

The H5 Any Door feature now includes a dedicated web view controller (DoraemonDefaultWebViewController) that displays a progress bar during page loading. Additionally, the feature integrates a QR code scanning capability, allowing users to scan a QR code to automatically populate and navigate to a URL.

iOS/DoraemonKit/Src/Core/Plugin/Common/H5 · high confidence

The Flutter/example directory now contains a complete, runnable example application. This includes the Dart entry point (main.dart) which integrates the DoKit debugging toolkit and configures method channel blacklisting, alongside the necessary Android (AndroidManifest, MainActivity, Gradle wrapper) and iOS (Xcode project, Info.plist, launch screens) platform configurations to support the Flutter engine and plugins.

Flutter/example · high confidence

This change introduces DoKit for Flutter, a debugging toolkit that provides features such as log viewing, network request monitoring, method channel information, route information, frame rate, memory usage, basic information, control inspection, color picker, widget hierarchy, page source code viewing, and page startup time tracking. The package supports Flutter version 1.17.5 and above, with a specific branch for Flutter 2.0 and null safety. The entry point is initialized via \DoKit.runApp\ or \DoKitApp\ wrapper, and the toolkit includes a custom overlay container to prevent \InheritedWidget\ conflicts. The release also includes a \.gitignore\ file, a \.metadata\ file for Flutter tooling, an \analysis\_options.yaml\ for code style, and a \flutterw\ script for managing the Flutter SDK version 2.0.6.

Flutter · high confidence

Adds the \dokit-leakcanary\ module to the Android/dokit codebase, integrating the Square LeakCanary library to detect and report memory leaks. This includes the necessary AndroidManifest configuration for services and activities, AIDL interfaces for cross-process communication, and manager classes to initialize LeakCanary and handle leak data via AIDL and Messenger bridges.

Android/dokit · high confidence

The DoKit Web interface is now available, featuring a draggable entry button and a main container that renders a home page, a router-based navigation system, and support for independent plugins. Users can now access the DoKit dashboard, navigate between features, and view element properties via a new highlight component.

Web/packages/core/src/components · high confidence

Added the core entry point for the Dokit Web package, establishing the main \Dokit\ class that initializes the Vue application, registers router and store, and manages lifecycle hooks. This includes support for multi-device control scenarios via \startMultiControl\ and \stopMultiControl\ methods, and native container detection.

Web/packages/core/src · high confidence

Added new files in the Flutter APM kit to manage the Dart VM service connection and parse Flutter version details. The \vm\_service\_wrapper.dart\ file provides a singleton wrapper to connect to the VM service, handle extension methods, and manage isolate references. The \vm\_helper.dart\ file acts as a helper to resolve VM information, including memory usage and allocation profiles. The \version.dart\ file introduces a \FlutterVersion\ class to parse and compare semantic versions of the Flutter framework and engine, enabling the APM kit to track and verify Flutter environment details.

Flutter/lib/kit/apm/vm · high confidence

The Android/dokit-mc module now contains the complete implementation for the 'one machine, multiple control' feature, including host and client controllers, connection management, and UI fragments. This change separates the automated testing and multi-control logic from the main DoKit codebase into a distinct module, providing a dedicated entry point (MultiControlKit) and supporting components like the DoKitMcActivity, WebSocket routing, and history management for connecting to and controlling remote devices.

Android/dokit-mc · high confidence

A new independent package for Dokit on the web is introduced, providing a self-contained build that includes the complete Vue runtime. This allows the web client to operate without external dependencies, bundling the core Dokit functionality and features into a single distributable file via a new Rollup configuration.

Web/packages/web-independent · high confidence

Added new Flutter UI components to support the DoKit debugging interface. The \DoKitApp\ widget wraps the application's root widget to inject a \DokitNavigatorObserver\ for non-invasive route observation. A draggable floating button (\DoKitBtn\) allows users to open the debug overlay. The overlay itself is managed via a \GlobalKey\ and uses a \Stack\ to prevent \InheritedWidget\ conflicts. Additional UI elements include a \KitPage\ for displaying tools, a \ResidentPage\ for persistent tool access, a \DashedDecoration\ for visual styling, and an \FpsChart\ for performance monitoring.

Flutter/lib/ui · high confidence

A new header file DoraemonDefine.h is added to the Core/Define directory, establishing the DoKit version as 3.0.8 and providing layout constants for iPhone X series devices (navigation bar, status bar, and safe area heights). The file also introduces utility macros for screen dimensions, interface orientation detection, string/array/dictionary validation, and logging control.

iOS/DoraemonKit/Src/Core/Define · high confidence

New protocol headers are added to define the interface for Doraemon plugins. DoraemonPluginProtocol specifies optional lifecycle methods for plugin loading, including a new overload that accepts an itemData dictionary. DoraemonStartPluginProtocol defines an optional startPluginDidLoad method. These protocols standardize how plugins are loaded and initialized within the DoraemonKit framework.

iOS/DoraemonKit/Src/Core/Plugin/Protocol · medium confidence

A new global store has been added to manage application state, including flags for container and highlight element visibility, lists for independent plugins and interfaces, and queues for multi-client communication. This provides a centralized mechanism for updating and retrieving global data, as well as adding or removing independent plugins.

Web/packages/core/src/store · high confidence

The web package now exposes a structured plugin system that organizes debugging capabilities into categories such as 'Common Tools' (including console, app info, network, storage, and scan code), 'Platform Features' (such as API mocking), and 'Visual Features' (like an align ruler). This change consolidates various web-side functionalities into a unified \Dokit\ instance, enabling users to access these development tools directly within the web environment.

Web/packages/web/src · high confidence

The DoraemonKit iOS library adds new base view controllers to standardize the appearance and behavior of internal screens. DoraemonBaseViewController provides a unified navigation bar and title bar implementation, including support for iOS 13 dark mode and proper key window management when input fields are focused. DoraemonStatusBarViewController ensures the status bar is correctly displayed on iOS 9.0+ systems, addressing issues where the status bar might otherwise be hidden. These changes improve visual consistency and compatibility across different iOS versions and device types.

iOS/DoraemonKit/Src/Core/Base · high confidence

The repository now includes new \dokit-core\ and \dokit-web\ packages, each with their own build configuration and documentation. The \dokit-core\ package provides a non-invasive container for customizing Dokit Web, supporting external configuration injection, plugin registration, and basic runtime capabilities. The \dokit-web\ package serves as the main web implementation, bundling into a global \dokit\ IIFE, and includes a console log component. Both packages are configured with Rollup to handle Vue components, PostCSS, and other standard web build steps.

Web/packages/web · high confidence

Added new classes for detecting main thread blocking and ANR conditions on iOS. The update introduces DoraemonANRManager to coordinate tracking, DoraemonANRTracker to perform the actual monitoring using a background ping thread, and DoraemonANRTool to persist collected ANR information to the local cache directory.

iOS/DoraemonKit/Src/Core/Plugin/Performance/ANR/Function · high confidence

The toolkit now includes a comprehensive set of performance monitoring and debugging kits. The APM suite adds dedicated tools for monitoring FPS, memory usage, HTTP requests, logs, method channels, route navigation, and source code viewing. Additionally, a new 'Basic Info' kit displays system details such as CPU, Dart VM version, Flutter version, and isolate information. These new kits provide deeper insights into application performance and state.

Flutter/lib/kit/apm · high confidence

The CocoaLumberjack logger list has been refactored into new view controllers and cells (DoraemonCocoaLumberjackListViewController, DoraemonCocoaLumberjackListCell, etc.) to support filtering logs by level (Verbose, Debug, Info, Warn, Error) via a segmented control. Users can now export logs as text, clear the log list, and copy individual log entries to the clipboard. The implementation includes a search view for filtering by message content and handles iOS 13 dark mode styling for the segment control.

iOS/DoraemonKit/Src/Logger/List · high confidence

Added a new DoraemonHealthManager component that manages application health checks, including CPU, memory, FPS, and network monitoring. The manager provides methods to start/stop health checks, reboot the app for health checks, and collect metrics like CPU usage, memory usage, FPS, and network flow. It also includes functionality for ANR (Application Not Responding) detection, UI thread monitoring, and memory leak detection.

iOS/DoraemonKit/Src/Core/Plugin/Platform/Health/Function · high confidence

Added a new JavaScript plugin that allows users to execute custom JavaScript code in the current WebView. The feature includes a list view to manage saved scripts, a detail view for editing and running scripts, and a manager that handles evaluation via WKWebView or UIWebView. The plugin also provides built-in scripts for debugging (vConsole), reloading, and navigating the page history.

iOS/DoraemonKit/Src/Core/Plugin/Common/JavaScript · high confidence

The Kit Manager screen has been refactored into a new \DoraemonKitManagerViewController\ with a dedicated \UICollectionView\-based UI. Users can now view all available DoraemonKit modules in a grid, toggle their enabled/disabled state via an edit mode, and reset the configuration to its initial state. The implementation includes new cell classes (\DoraemonKitManagerCell\, \DoraemonKitManagerHeadCell\, \DoraemonKitManagerResetCell\) that support custom icons and selection states.

iOS/DoraemonKit/Src/Core/Entry/Home/Settings/KitManager · high confidence

The iOS DoraemonKit now includes a new NetFlow plugin that provides a dedicated interface for monitoring and inspecting network traffic. Users can view a list of intercepted HTTP requests and responses, with detailed breakdowns of headers, body content, and performance metrics like duration and data size. The plugin also introduces a real-time oscillogram window that visualizes network flow activity, and allows users to toggle network monitoring on or off via the main DoraemonKit home screen. This adds a new capability to the toolkit for debugging and analyzing network behavior.

iOS/DoraemonKit/Src/Core/Plugin/Performance/NetFlow · high confidence

The Settings screen has been replaced with a new \DoraemonSettingViewController\ that fetches a list of menu items from a remote JSON configuration. Each item can be either a native navigation to the Kit Manager or a web view, allowing the menu structure to be updated remotely without app updates.

iOS/DoraemonKit/Src/Core/Entry/Home/Settings · high confidence

The DoraemonKit iOS plugin for checking UI rendering on non-main threads has been added. This feature intercepts \setNeedsLayout\, \setNeedsDisplay\, and \setNeedsDisplayInRect\ on \UIView\ instances to detect and log violations where UI updates occur off the main thread. Users can toggle this check via a switch in the DoraemonKit interface and view a list of detected issues with detailed backtrace logs.

iOS/DoraemonKit/Src/Core/Plugin/Performance/SubThreadUICheck · high confidence

Added new debugging components for miniapps: an API mock tool that allows developers to intercept and modify API responses for testing; an HTTP request injector that enables interception and modification of network requests; and a log viewer that captures and displays console logs (debug, log, info, warn, error) for easier inspection. These tools are now available in the debug menu.

miniapp/src · high confidence

The DoraemonKit now introduces a new floating entry window (DoraemonEntryWindow) that serves as the primary UI entry point. Users can drag this floating button around the screen, and it will automatically dock to the nearest screen edge when released. The window also supports an 'auto-dock' mode that can be toggled, and it respects the user's last known position. The implementation includes dark mode support for the button's image and integrates with the existing home window to show/hide the main tool panel.

iOS/DoraemonKit/Src/Core/Entry/Entry · high confidence

The DoraemonKit iOS SDK now includes a new Mock plugin that allows users to manage and upload mock data. This feature introduces a new plugin entry point and a dedicated UI for browsing, filtering, and selecting mock APIs and upload templates. The implementation includes a manager to handle data fetching, caching, and state management, along with view controllers for listing APIs and uploading templates. Users can now view mock data, filter by groups and states, and upload local mock data templates.

iOS/DoraemonKit/Src/Core/Plugin/Platform/Mock · high confidence

Added a new set of UI components for displaying performance metrics (CPU, FPS, Memory, NetFlow) as oscillograms. This includes a reusable \DoraemonOscillogramView\ for rendering line charts, a \DoraemonOscillogramViewController\ to manage the view hierarchy, and a \DoraemonOscillogramWindow\ to present the charts in an overlay window. A \DoraemonOscillogramWindowManager\ is also introduced to coordinate the layout of these four specific monitoring charts, supporting both portrait and landscape orientations.

iOS/DoraemonKit/Src/Core/CommonUI/Oscillogram · high confidence

The DoraemonKit settings interface now uses dedicated \DoraemonCellInput\ and \DoraemonCellSwitch\ components. These new views provide consistent, reusable UI elements for displaying text inputs and toggle switches within the settings menu, improving the visual consistency of the settings page.

iOS/DoraemonKit/Src/Core/CommonUI/CellInput, iOS/DoraemonKit/Src/Core/CommonUI/CellSwitch · high confidence

Added two new visual debugging components to the iOS SDK: a floating info window for displaying text or attributed strings, and a magnifier window for zooming in on specific screen areas. The info window supports iOS 13 dark mode by dynamically swapping close button images and background colors based on the current user interface style. The magnifier window implements a custom layer rendering approach to provide a zoomed-in view of the target window's content. Both components are designed to be used for visual inspection and debugging within the app.

iOS/DoraemonKit/Src/Core/CommonUI/Visual · high confidence

The iOS demo application has been reorganized into a modular structure with dedicated view controllers for each feature: a home screen listing all demos, and separate screens for logging, crash simulation, memory leak testing, GPS mocking, and multi-control gesture testing (long press, pinch, rotation, swipe, and edge pan). The app now uses a base view controller for consistent navigation bar styling and includes new asset catalogs for app icons and images. This change improves the demo's organization and provides clearer examples of each DoraemonKit feature.

iOS/DoraemonKitDemo/DoraemonKitDemo · high confidence

The Xcode project file (project.pbxproj) and workspace configuration for the DoraemonKit iOS demo application have been added to the repository. This establishes the build configuration for the demo app, including references to source files for features like multi-control gestures, memory leak detection, network monitoring, and crash logging, as well as resources such as images, HTML, and media files.

iOS/DoraemonKitDemo/DoraemonKitDemo.xcodeproj · high confidence

The iOS DoraemonKit now includes a complete set of new files for the 'one-device-multi-control' feature, introducing client-server communication, event capturing, command generation, and serialization logic. Specifically, the diff adds \DoraemonMCClient\ and \DoraemonMCServer\ for handling network communication, \DoraemonMCCommandGenerator\ and \DoraemonMCCommandExcutor\ for creating and processing control commands, and \DoraemonMCEventCapturer\ to intercept UI events (gestures, controls, text input) and serialize them for transmission. Additionally, helper classes like \DoraemonMCMessagePackager\ and various serializer categories (e.g., \UIGestureRecognizer+DoraemonMCSerializer\) are added to manage message formatting and state synchronization across devices.

iOS/DoraemonKit/Src/MultiControl/Function · high confidence

Introduces a new DoraemonBaseBigTitleView component that adapts to iOS 13's Dark Mode. The view now dynamically adjusts title text color and the close button image based on the current user interface style (light vs. dark), ensuring proper contrast and visual consistency in both modes.

iOS/DoraemonKit/Src/Core/Base/View · high confidence

The Health plugin now presents an alert view when ending a health check, requiring users to input the test case name and tester name before submission. The interface includes 'Submit', 'Discard', and 'Cancel' actions, allowing users to either save the health check data, discard it without saving, or cancel the operation entirely.

iOS/DoraemonKit/Src/Core/Plugin/Platform/Health · high confidence

A new umbrella header, DoraemonKit.h, was added to the Core directory. This header aggregates the public interfaces for DoraemonManager and DoraemonBaseViewController, providing a single import point for the SDK's core components.

iOS/DoraemonKit/Src/Core · high confidence

The alert functionality has been extracted from the toast component into a new, dedicated utility class (DoraemonAlertUtil). This provides a standardized way to present alert dialogs with customizable titles, messages, and action blocks, improving code reuse and consistency across the app.

iOS/DoraemonKit/Src/Core/CommonUI/Alert · medium confidence

The NSLog list view has been refactored to use new, dedicated components: DoraemonNSLogListCell for displaying log entries, DoraemonNSLogListViewController to manage the list, and DoraemonNSLogSearchView to handle search input. This change introduces a search bar that filters the log list by content and updates the table view dynamically, while the cell component handles rendering individual log items with expandable details.

iOS/DoraemonKit/Src/Core/Plugin/Common/NSLog/List · high confidence

The NSLog plugin has been restructured into dedicated components: a new \DoraemonNSLogPlugin\ entry point, a \DoraemonNSLogViewController\ for the settings UI, and a \DoraemonNSLogManager\ that handles log interception via \fishhook\ (swizzling \NSLog\). The \DoraemonNSLogModel\ is introduced to store log entries. This change isolates the NSLog functionality into a self-contained plugin structure, enabling dynamic start/stop of log monitoring without app restarts.

iOS/DoraemonKit/Src/Core/Plugin/Common/NSLog/Function · medium confidence

Added new UI components for the Weex Storage feature, including DoraemonWeexStorageCell, DoraemonWeexStorageRowView, and DoraemonWeexStorageShowView. These views implement iOS 13 Dark Mode compatibility by conditionally applying system colors (such as secondarySystemBackgroundColor and labelColor) on iOS 13 and later, while falling back to hardcoded hex colors for earlier versions. This ensures the Storage view displays correctly in both light and dark modes.

iOS/DoraemonKit/Src/Weex/Storage/View · high confidence

The home page UI has been refactored into dedicated cell classes (DoraemonHomeCell, DoraemonHomeCloseCell, DoraemonHomeFootCell, and DoraemonHomeHeadCell). These new components handle the display of tool icons and names, a close button with a confirmation dialog, a footer title, and a header with title and subtitle rendering. The implementation includes iOS 13+ dark mode support for background colors and labels.

iOS/DoraemonKit/Src/Core/Entry/Home/Cell · high confidence

The DoKit home entry has been rebuilt using a UICollectionView to display plugin icons, replacing the previous implementation. This change introduces new components including DoraemonHomeViewController, DoraemonHomeWindow, and DoraemonNavigationController. The new home screen supports dynamic theming for iOS 13+ (using system background colors), handles screen rotation via the DoraemonManager's supportedInterfaceOrientations property, and manages the overlay window for the DoKit interface. The layout adapts to different screen sizes and orientations, fixing issues with button obstruction and landscape mode rendering.

iOS/DoraemonKit/Src/Core/Entry/Home · high confidence

The UI for the UI Hierarchy plugin has been completely rebuilt with new view controllers, table view controllers, and custom table cells. The \DoraemonHierarchyViewController\ now manages a picker overlay and an info view (\DKHierarchyInfoView\) that displays details about the selected view. The detail view (\DoraemonHierarchyDetailViewController\) uses a segmented control to switch between 'Object' and 'Size' hierarchies. New cell types (\DoraemonHierarchyTitleCell\, \DoraemonHierarchyDetailTitleCell\, \DoraemonHierarchySelectorCell\, \DoraemonHierarchySwitchCell\) provide a consistent look and feel for displaying hierarchy data. The \DoraemonHierarchyWindow\ is now properly configured for iOS 13+ multi-scene support.

iOS/DoraemonKit/Src/Core/Plugin/UI/Hierarchy/UserInterface · high confidence

The Weak Network performance plugin's user interface has been restructured into dedicated view classes: DoraemonWeakNetworkDetailView, DoraemonWeakNetworkLevelView, and DoraemonWeakNetworkInputView. This change separates the display of network condition types (e.g., timeout, speed limit) from the input fields for configuring delay and bandwidth, providing a cleaner and more maintainable interface for adjusting weak network simulation settings.

iOS/DoraemonKit/Src/Core/Plugin/Performance/WeakNetwork/View · high confidence

The QR code scanning functionality in the H5 plugin has been replaced with a new DoraemonQRScanView component. This new implementation provides a customizable camera view for scanning QR codes, featuring a delegate-based callback system for scan results and brightness levels. It supports customizing the scan area, scan line, corner lines, and border lines, and handles camera permissions and status checks internally. This change addresses previous issues with the H5 'any door' scanning feature, specifically fixing a crash related to mask views and ensuring that only one browser page opens upon successful scan.

iOS/DoraemonKit/Src/Core/Plugin/Common/H5/QRCode · high confidence

The source code view has been updated to include syntax highlighting for Dart code, improving readability with color-coded keywords, comments, and strings. This change requires a minimum Flutter version of 2.0.0 and is compatible with Dart's null safety.

_Flutter/lib/widget/source\code · high confidence

Added initial widget test scaffold; Added placeholder test files for core, utils, and web packages.

The Android build configuration has been updated to support multiple Kotlin versions (1.3.72 and 1.4.32) and Android Gradle Plugin versions (4.2.2 and 7.0.0) via the \config.gradle\ file. The \doraemonkit.gradle\ script now conditionally applies either the local debug plugin or the remote \dokitx\ release plugin based on the \run\_type\ configuration. Additionally, the project structure includes new or updated \build.gradle\ files for various DoKit modules (such as \dokit-autotest\, \dokit-ft\, \dokit-gps-mock\, \dokit-leakcanary\, \dokit-mc\, \dokit-no-op\, \dokit-okhttp-api\, \dokit-plugin\, and \dokit-pthread-hook\), each defining their specific dependencies and build settings.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 38 (+1.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 60 → 62 (+2.1)
• Architecture 87 → 86 (-0.2)
• Maturity 48 → 48 (+0.0)
• Readiness 28 → 29 (+1.0)
• Security 62 → 70 (+7.9)
• Accessibility 30 → 32 (+2.1)

• (anonymous) (cognitive 27) (Web/packages/core/src/common/js/EventPlayback.js)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (Android/dokit-gps-mock/src/main/java/com/didichuxing/doraemonkit/gps_mock/map/BDAbsLocationListenerProxy.java)
• Duplicated block (10 lines × 2) (Android/dokit-gps-mock/src/main/java/com/didichuxing/doraemonkit/gps_mock/widget/OverlayManager.java)
• Duplicated block (10 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/network/ui/InterceptDetailNodeProvider.java)
• Duplicated block (10 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/toolpanel/decoration/FlexibleDividerDecoration.java)
• Duplicated block (10 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/toolpanel/decoration/HorizontalDividerItemDecoration.java)
• Duplicated block (10 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/uiperformance/UIPerformanceManager.java)
• Duplicated block (10 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/util/DoKitNotificationUtils.java)
• Duplicated block (10 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/widget/jsonviewer/adapter/JsonViewerAdapter.java)
• Duplicated block (10 lines × 3) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/network/room_db/MockInterceptApiBean.java)
• Duplicated block (11 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/largepicture/LargePictureManager.java)
• Duplicated block (11 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/toolpanel/decoration/HorizontalDividerItemDecoration.java)
• Duplicated block (12 lines × 2) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/toolpanel/decoration/HorizontalDividerItemDecoration.java)
• …and 112 more

• AbsDoKitView.resetBorderline (cognitive 62) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/core/AbsDoKitView.kt)
• AbsDoKitView.resetBorderline (cyclomatic 21) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/core/AbsDoKitView.kt)
• AbsDoKitView.updateViewLayout (cognitive 17) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/core/AbsDoKitView.kt)
• BaseNodeAdapter.flatData (cognitive 16) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/widget/brvah/BaseNodeAdapter.kt)
• BaseQuickAdapter.getInstancedGenericKClass (cognitive 20) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/widget/brvah/BaseQuickAdapter.kt)
• BaseQuickAdapter.getItemViewType (cognitive 23) (Android/dokit/src/main/java/com/didichuxing/doraemonkit/widget/brvah/BaseQuickAdapter.kt)
• BigImgClassTransformer.transform (cognitive 17) (Android/dokit-plugin/src/main/kotlin/com/didichuxing/doraemonkit/plugin/transform/classtransform/BigImgClassTransformer.kt)
• BigImgClassTransformer.transform (cyclomatic 18) (Android/dokit-plugin/src/main/kotlin/com/didichuxing/doraemonkit/plugin/transform/classtransform/BigImgClassTransformer.kt)
• ClassTooLong: AbsDoKitView (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/core/AbsDoKitView.kt)
• ClassTooLong: BaseQuickAdapter (Android/dokit/src/main/java/com/didichuxing/doraemonkit/widget/brvah/BaseQuickAdapter.kt)
• ClassTooLong: EasyRefreshLayout (Android/dokit/src/main/java/com/didichuxing/doraemonkit/widget/easyrefresh/EasyRefreshLayout.java)
• ClassTooLong: GpsMockFragment (Android/dokit-gps-mock/src/main/java/com/didichuxing/doraemonkit/gps_mock/gpsmock/GpsMockFragment.java)
• ClassTooLong: NetWorkMockFragment (Android/dokit/src/main/java/com/didichuxing/doraemonkit/kit/network/ui/NetWorkMockFragment.java)
• ClassTooLong: ObsoleteUrlFactory (Android/dokit/src/main/java/com/didichuxing/doraemonkit/aop/urlconnection/ObsoleteUrlFactory.java)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• Critical CVE: [GHSA redacted] (miniapp/package-lock.json)
• DartSyntaxHighlighter._generateSpans (cognitive 50) (Flutter/lib/widget/source_code/syntax_highlighter.dart)
• …and 192 more

• Containers 0 added · 0 removed · contexts 15 added · 2 removed · edges 17 added · 0 removed

• app
• dokit
• dokit-autotest
• dokit-ft
• dokit-gps-mock
• dokit-leakcanary
• dokit-mc
• dokit-no-op
• dokit-okhttp-api
• dokit-okhttp-v3
• dokit-okhttp-v4
• dokit-plugin
• dokit-pthread-hook
• dokit-util
• dokit-weex

• .
• android

• app → dokit
• app → dokit-no-op
• dokit → dokit-no-op (coupling)
• dokit → dokit-util
• dokit-autotest → dokit (coupling)
• dokit-autotest → dokit-no-op
• dokit-ft → dokit (coupling)
• dokit-ft → dokit-no-op
• dokit-gps-mock → dokit (coupling)
• dokit-gps-mock → dokit-no-op
• dokit-mc → dokit (coupling)
• dokit-mc → dokit-no-op
• dokit-no-op → dokit
• dokit-pthread-hook → dokit
• dokit-pthread-hook → dokit-no-op
• dokit-weex → dokit
• dokit-weex → dokit-no-op

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

didi/DoKit was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.