* feat (Connection Statistics): Restored the server connection statistics feature
* perf(store): Optimize data storage performance and implement caching mechanisms
- Implement caching mechanisms in SnippetStore and ServerStore to reduce redundant loading
- Refactor ConnectionStatsStore to use indexes and optimize query performance
- Adopt a more efficient approach when cleaning up expired records
- Add a maximum record limit to prevent data bloat
* perf(store): Optimize data storage performance and add a caching mechanism
Add a caching mechanism to PrivateKeyStore to reduce redundant loading
Make the cleanup and index rebuilding of ConnectionStatsStore asynchronous
Add database compression and size statistics
Display database size in the interface and optimize compression operations
* fix (Cache): Fixed cache invalidation and join statistics issues
- Added a cache invalidation call to the reload method
- Fixed an error in the calculation of join statistics timestamps
- Optimized the cache index rebuild logic
- Added tooltips and click effects for join statistics
* refactor(connection_stats): Convert file operations from synchronous to asynchronous and optimize record cleanup logic
Convert the database size retrieval method from synchronous to asynchronous to prevent UI blocking
Optimize server record cleanup logic by directly deleting redundant records instead of rebuilding indexes
* fix(connection_stats): Fixed an initialization issue when the index database is empty
During Stores initialization, the code now checks whether `connectionStats.indexDbKeys` is empty; if so, it calls `rebuildIndexAndCompact` to rebuild and compact the database. Additionally, the implementation of the `_pruneExcessRecords` method has been optimized to use tuples instead of temporary lists, thereby improving performance. A `mounted` check has been added at the UI layer to prevent state update issues during asynchronous operations.
* fix(server): Improved error string matching logic to more accurately identify connection issues
Error strings are now uniformly converted to lowercase for comparison, and matching criteria have been expanded to cover a wider range of error scenarios, including timeouts, authentication failures, and network errors
* fix(PrivateKeyStore): Fixed an issue where the cache state was not updated when clearing the cache
When clearing the private key store, ensure that the internal cache state is updated simultaneously to maintain consistency
* refactor(store): Add close methods and clean up subscription logic
Add close methods to PrivateKeyStore, SnippetStore, and ServerStore to unsubscribe
Unify cache cleanup logic to prevent memory leaks
* fix(store): Add a cache update suppression mechanism to prevent circular updates
Add an _suppressWatch flag to multiple Store classes to suppress cache invalidation during internal operations
Add a _putWithoutInvalidatingCache method to prevent recursive watchers from being triggered during data updates
* refactor(store): Improve caching and state management using try-finally
In PrivateKeyStore, ServerStore, and SnippetStore:
1. Remove redundant close methods
2. Use try-finally to ensure the _suppressWatch state is reset correctly
3. Optimize cache invalidation logic
4. Standardize transaction handling for update operations
* refactor(store): Optimize data storage operations and fix potential issues
- Ensure the safety and consistency of list operations in ConnectionStatsStore
- Replace direct calls to `box.put` with the `set` method in SnippetStore and ServerStore
- Extract decoding logic for PrivateKeyStore into a separate method
- Add logic to update server-hopping relationships
* fix: Fixed an issue where asynchronous operations were not being waited on and optimized storage operations
Fixed several issues where asynchronous operations were not being waited on to ensure data consistency
Added the _suppressWatch control to ServerStore and PrivateKeyStore
Optimized index management in ConnectionStatsStore to maintain record order
Added a new GitHub participant
* fix: Fixed potential state issues and memory leaks in asynchronous operations
Fixed potential state issues that could occur on the server edit page after a delete operation; added a mounted check
Changed the statistics clearing operation in connection_stats to run asynchronously
Optimized asynchronous operations in PrivateKeyStore and fixed potential memory leaks
* refactor(store): Convert asynchronous methods to synchronous ones to simplify the code
Fixed an issue where asynchronous operations were not handled correctly on the connection statistics page
* fix: Added mounted check and error handling for connection logs
Added a mounted check in _ConnectionStatsPageState to prevent the state from being updated after the component is unmounted
Added a try-catch block for connection logs in ServerNotifier to catch and log potential storage exceptions
* refactor(server): Replace Future.wait with an explicit list of futures to enhance readability
Refactor the nested map and async functions into explicit for loops and future lists to make the code logic clearer
* fix(server): Fixed the auto-refresh logic and concurrency control issues
- Add `_refreshCompleter` to prevent concurrent refreshes
- Fixed the issue where the status was not updated after the automatic refresh timer was canceled
- Remove the invalid check for `duration == 1`
* refactor(server): Optimize the server refresh logic by filtering out servers that do not need to be refreshed in advance
Move the server filtering logic outside the loop and use the `where` method to filter the servers that need to be refreshed, avoiding repeated condition checks within the loop. This improves code readability and reduces redundant condition checks.
* refactor: Optimize server refresh logic to enhance readability
Break down complex conditional checks into clearer steps, separating the logic for server refresh and rate limiter reset. Replace chained calls with explicit loops to make the code easier to maintain and understand.
* refactor(server): Remove `updateFuture` from `ServerState` and use the `_isRefreshing` flag instead
Simplify the server refresh logic, replace Future state tracking with a boolean flag, and avoid unnecessary state updates
* refactor(server_detail): Extract the setting items as local variables to improve performance
Extract the globally set items that are accessed repeatedly as local variables, reduce unnecessary state retrieval operations, and optimize page performance
* refactor: Rename `_displayCpuIndexSetting` to `_displayCpuIndex` for consistency
* refactor(server): Fix the issue of parallel blocking in server refresh
The original code uses Future.wait to wait for all refresh operations to complete, but in fact, there is no need to wait for the results of these operations. Instead, directly calling ignore() to ignore the results can avoid blocking caused by the slowest server
* fix: Adjust the order of logging and default value settings
Ensure to set the default value after recording the invalid duration warning
* refactor(server): Rename _refreshCompleter to _refreshInProgress to enhance readability
Change the variable name from `_refreshCompleter` to `_refreshInProgress`, so that it more accurately reflects the actual purpose of the variable, which is to indicate whether the refresh operation is in progress
* refactor(server): Remove unnecessary refresh progress status management
Simplify the server refresh logic, remove the unused _refreshInProgress state variable and related Completer handling, making the code more concise and straightforward
* chore: Update dependent package versions
Update the following dependent package versions:
- camera_web has been upgraded from 0.3.5 to 0.3.5+3
- ffi has been upgraded from 2.1.4 to 2.1.5
- hive_ce_flutter is upgraded from 2.3.3 to 2.3.4
- watcher is upgraded from 1.1.4 to 1.2.1
* opt.
---------
Co-authored-by: lollipopkit🏳️⚧️ <10864310+lollipopkit@users.noreply.github.com>
