From e28fa2aeaa7878e9a09869a65185ec26d65673cb Mon Sep 17 00:00:00 2001 From: zarzet <42882290+zarzet@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:36:42 +0700 Subject: [PATCH] perf(bridge): avoid redundant download and small job codecs Keep download snapshots as JSON across the Android channel and decode large progress payloads off the UI isolate while retaining event order and permissive empty-result behavior. Encode bounded small native data requests inline, with the existing pre-dispatch cancellation yield and background fallback for larger graphs. Host tests verify zero encoder isolates for small requests, background decoding of large snapshots, cursor resets, stream cancellation, exact JSON and separate binary arguments. Restoring the old codec paths fails the corresponding isolate and event-loop probes. --- .../mornye/MainActivityProgressStreams.kt | 25 ++-- .../zarz/mornye/MainActivityServiceCalls.kt | 11 +- .../mornye/DownloadProgressSequenceTest.kt | 24 +++ lib/services/platform_bridge.dart | 20 ++- .../platform_bridge/bridge_codec.dart | 30 ++++ test/native_data_job_bridge_test.dart | 109 ++++++++++++++ .../native_download_progress_bridge_test.dart | 141 ++++++++++++++++++ 7 files changed, 338 insertions(+), 22 deletions(-) create mode 100644 android/app/src/test/kotlin/com/zarz/mornye/DownloadProgressSequenceTest.kt create mode 100644 test/native_download_progress_bridge_test.dart diff --git a/android/app/src/main/kotlin/com/zarz/mornye/MainActivityProgressStreams.kt b/android/app/src/main/kotlin/com/zarz/mornye/MainActivityProgressStreams.kt index 8e0995c33..9721c317c 100644 --- a/android/app/src/main/kotlin/com/zarz/mornye/MainActivityProgressStreams.kt +++ b/android/app/src/main/kotlin/com/zarz/mornye/MainActivityProgressStreams.kt @@ -9,6 +9,8 @@ import kotlinx.coroutines.isActive import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import java.util.concurrent.atomic.AtomicReference +import org.json.JSONObject +import org.json.JSONTokener private val DOWNLOAD_PROGRESS_STREAM_CHANNEL = "com.zarz.mornye/download_progress_stream" @@ -54,12 +56,15 @@ internal fun MainActivity.registerProgressStreams(messenger: BinaryMessenger) { ) } -private fun MainActivity.updateDownloadProgressSeq(progress: Any?) { - val objectValue = progress as? Map<*, *> ?: return - val seq = (objectValue["seq"] as? Number)?.toLong() ?: lastDownloadProgressSeq - if (objectValue["reset"] == true || seq > lastDownloadProgressSeq) { - lastDownloadProgressSeq = seq +internal fun downloadProgressSequence(payload: String, previous: Long): Long { + if (payload.isEmpty()) return previous + val progress = try { + JSONTokener(payload).nextValue() as? JSONObject ?: return previous + } catch (_: Exception) { + return previous } + val seq = (progress.opt("seq") as? Number)?.toLong() ?: previous + return if (progress.opt("reset") == true || seq > previous) seq else previous } private fun MainActivity.startDownloadProgressStream(sink: EventChannel.EventSink) { @@ -73,19 +78,17 @@ private fun MainActivity.startDownloadProgressStream(sink: EventChannel.EventSin try { while (isActive && downloadProgressConnection === connection) { try { - // Decode once on IO. Reset snapshots of large queues - // previously parsed twice on the UI thread. - val (payload, progress) = withContext(Dispatchers.IO) { + val (payload, sequence) = withContext(Dispatchers.IO) { val reader = connection.get() ?: coreBackend.openDownloadProgress().also { connection.set(it) } ensureActive() val payload = reader.waitDelta(lastDownloadProgressSeq, 15_000L) - payload to if (payload.isEmpty()) null else parseJsonPayload(payload) + payload to downloadProgressSequence(payload, lastDownloadProgressSeq) } if (!isActive || downloadProgressConnection !== connection) break if (payload.isNotEmpty() && payload != lastDownloadProgressPayload) { - updateDownloadProgressSeq(progress) + lastDownloadProgressSeq = sequence lastDownloadProgressPayload = payload - sink.success(progress) + sink.success(payload) delay(250L) } } catch (e: Exception) { diff --git a/android/app/src/main/kotlin/com/zarz/mornye/MainActivityServiceCalls.kt b/android/app/src/main/kotlin/com/zarz/mornye/MainActivityServiceCalls.kt index 5da672eb4..2be452748 100644 --- a/android/app/src/main/kotlin/com/zarz/mornye/MainActivityServiceCalls.kt +++ b/android/app/src/main/kotlin/com/zarz/mornye/MainActivityServiceCalls.kt @@ -110,14 +110,11 @@ internal fun MainActivity.handleAcknowledgeNativeDownloadWorkerItems(call: Metho internal suspend fun MainActivity.handleGetNativeDownloadWorkerSnapshot(call: MethodCall, result: MethodChannel.Result) { val sinceStateSerial = (call.argument("since_state_serial") ?: 0L).toLong() - // The snapshot can be megabytes late in a large - // batch; read and parse it off the main thread. + // Keep large snapshots as JSON rather than re-encoding a map on Main. val payload = withContext(Dispatchers.IO) { - parseJsonPayload( - DownloadService.getNativeWorkerSnapshot( - this@handleGetNativeDownloadWorkerSnapshot, - sinceStateSerial - ) + DownloadService.getNativeWorkerSnapshot( + this@handleGetNativeDownloadWorkerSnapshot, + sinceStateSerial ) } result.success(payload) diff --git a/android/app/src/test/kotlin/com/zarz/mornye/DownloadProgressSequenceTest.kt b/android/app/src/test/kotlin/com/zarz/mornye/DownloadProgressSequenceTest.kt new file mode 100644 index 000000000..8820d39d3 --- /dev/null +++ b/android/app/src/test/kotlin/com/zarz/mornye/DownloadProgressSequenceTest.kt @@ -0,0 +1,24 @@ +package com.zarz.mornye + +import org.junit.Assert.assertEquals +import org.junit.Test + +class DownloadProgressSequenceTest { + @Test + fun advancesOnlyForNewEventsOrAnExplicitReset() { + assertEquals(5L, downloadProgressSequence("{\"seq\":5}", 4L)) + assertEquals(4L, downloadProgressSequence("{\"seq\":3}", 4L)) + assertEquals(3L, downloadProgressSequence("{\"seq\":3,\"reset\":true}", 4L)) + assertEquals(4L, downloadProgressSequence("{\"seq\":3,\"reset\":\"true\"}", 4L)) + assertEquals(4L, downloadProgressSequence("{\"reset\":true}", 4L)) + assertEquals(4L, downloadProgressSequence("{\"seq\":\"5\"}", 4L)) + assertEquals(5L, downloadProgressSequence("{\"seq\":5.9}", 4L)) + } + + @Test + fun missingOrInvalidObjectsKeepTheCursorWithoutChangingThePayload() { + for (payload in listOf("", "null", "[]", "1", "{broken", "{}")) { + assertEquals(9L, downloadProgressSequence(payload, 9L)) + } + } +} diff --git a/lib/services/platform_bridge.dart b/lib/services/platform_bridge.dart index a490dec16..baad28a4e 100644 --- a/lib/services/platform_bridge.dart +++ b/lib/services/platform_bridge.dart @@ -95,7 +95,7 @@ class PlatformBridge { final states = _nativeDataJobs.putIfAbsent(id, () => {}); states.add(state); try { - final encoded = await compute(_encodeJsonInBackground, request); + final encoded = await _encodeNativeDataJobRequest(request); if (state.cancelled) { throw PlatformException( code: 'CANCELLED', @@ -993,10 +993,12 @@ class PlatformBridge { } static Future> getAllDownloadProgress() async => - _decodeMapResult(await _channel.invokeMethod('getAllDownloadProgress')); + _decodeProgressMapAsync( + await _channel.invokeMethod('getAllDownloadProgress'), + ); static Stream> downloadProgressStream() { - return _channel.downloadProgressEvents().map(_decodeMapResult); + return _channel.downloadProgressEvents().asyncMap(_decodeProgressMapAsync); } static Future exitApp() => _invokeVoid('exitApp'); @@ -1839,7 +1841,7 @@ class PlatformBridge { /// only compact progress fields are returned. static Future> getNativeDownloadWorkerSnapshot({ int sinceStateSerial = 0, - }) async => _decodeMapResult( + }) async => _decodeProgressMapAsync( await _channel.invokeMethod('getNativeDownloadWorkerSnapshot', { 'since_state_serial': sinceStateSerial, }), @@ -2807,6 +2809,16 @@ class PlatformBridge { return const {}; } + static Future> _decodeProgressMapAsync( + dynamic result, + ) async { + if (result is! String || result.isEmpty) return _decodeMapResult(result); + final decoded = await _decodeJsonStringAsync(result); + return decoded is Map + ? decoded.cast() + : const {}; + } + /// Present the native iOS folder picker. The security-scoped bookmark is /// created inside the picker callback while its access grant is still /// active; creating it later from a bare path loses the grant. diff --git a/lib/services/platform_bridge/bridge_codec.dart b/lib/services/platform_bridge/bridge_codec.dart index 8734730e8..6e3ec47fa 100644 --- a/lib/services/platform_bridge/bridge_codec.dart +++ b/lib/services/platform_bridge/bridge_codec.dart @@ -3,6 +3,36 @@ part of '../platform_bridge.dart'; Object? _decodeJsonInBackground(String json) => jsonDecode(json); String _encodeJsonInBackground(Object? value) => jsonEncode(value); +Future _encodeNativeDataJobRequest(Map request) async { + var nodes = 0; + var characters = 0; + bool small(Object? value, int depth) { + if (++nodes > 256 || depth > 8) return false; + if (value == null || value is bool || value is num) return true; + if (value is String) { + characters += value.length; + return characters <= 16 * 1024; + } + if (value is List) { + if (value.length > 64) return false; + return value.every((item) => small(item, depth + 1)); + } + if (value is Map) { + if (value.length > 64) return false; + return value.entries.every( + (entry) => + entry.key is String && + small(entry.key, depth + 1) && + small(entry.value, depth + 1), + ); + } + return false; + } + + if (small(request, 0)) return jsonEncode(request); + return compute(_encodeJsonInBackground, request); +} + String _encodeBoundedLookupCacheInBackground(Map entries) { final result = StringBuffer('{'); var bytes = 2; // Opening and closing braces. diff --git a/test/native_data_job_bridge_test.dart b/test/native_data_job_bridge_test.dart index 77c69e76c..9bbe851fa 100644 --- a/test/native_data_job_bridge_test.dart +++ b/test/native_data_job_bridge_test.dart @@ -1,9 +1,35 @@ import 'dart:async'; +import 'dart:collection'; +import 'dart:convert'; +import 'dart:isolate'; import 'package:flutter/services.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:mornye/services/platform_bridge.dart'; +class _EncodingLocationMap extends MapBase { + _EncodingLocationMap(this._values); + + final Map _values; + + @override + Iterable get keys => [..._values.keys, 'encoding_isolate']; + + @override + dynamic operator [](Object? key) => + key == 'encoding_isolate' ? Isolate.current.debugName : _values[key]; + + @override + void operator []=(String key, dynamic value) => + throw UnsupportedError('read only'); + + @override + void clear() => throw UnsupportedError('read only'); + + @override + dynamic remove(Object? key) => throw UnsupportedError('read only'); +} + void main() { TestWidgetsFlutterBinding.ensureInitialized(); const channel = MethodChannel('com.zarz.mornye/backend'); @@ -21,6 +47,89 @@ void main() { tearDown(() => messenger.setMockMethodCallHandler(channel, null)); + for (final scenario in [ + ( + name: 'small scalars', + values: {'path': '/song.flac'}, + background: false, + ), + ( + name: 'bounded list', + values: {'items': List.filled(64, 1)}, + background: false, + ), + ( + name: 'long list', + values: {'items': List.filled(65, 1)}, + background: true, + ), + ( + name: 'long string', + values: {'text': 'x' * (16 * 1024)}, + background: true, + ), + ( + name: 'wide map', + values: {for (var i = 0; i < 65; i++) '$i': i}, + background: true, + ), + ( + name: 'aggregate nodes', + values: { + 'items': List.generate(8, (_) => List.filled(64, 1)), + }, + background: true, + ), + ( + name: 'aggregate text', + values: {'items': List.filled(32, 'x' * 1024)}, + background: true, + ), + ]) { + test('encodes ${scenario.name} on the expected isolate', () async { + late Map encoded; + messenger.setMockMethodCallHandler(channel, (call) async { + encoded = + jsonDecode((call.arguments as Map)['request_json'] as String) + as Map; + return '{}'; + }); + await PlatformBridge.runNativeDataJob( + _EncodingLocationMap(scenario.values), + ); + expect( + encoded.remove('encoding_isolate'), + scenario.background + ? isNot(Isolate.current.debugName) + : Isolate.current.debugName, + ); + expect(encoded, scenario.values); + }); + } + + test( + 'inline encoding preserves JSON and separate binary arguments', + () async { + final request = { + 'operation': 'palette', + 'path': '/Music/Example ♫/song.flac', + 'options': { + 'enabled': true, + 'missing': null, + 'values': [1, 2.5, 'a\nb'], + }, + }; + final bytes = Uint8List.fromList([0, 127, 255]); + messenger.setMockMethodCallHandler(channel, (call) async { + final args = call.arguments as Map; + expect(args['request_json'], jsonEncode(request)); + expect(args['bytes'], bytes); + return '{}'; + }); + await PlatformBridge.runNativeDataJob(request, bytes: bytes); + }, + ); + test( 'cancel before encoding completes never dispatches an idle job', () async { diff --git a/test/native_download_progress_bridge_test.dart b/test/native_download_progress_bridge_test.dart new file mode 100644 index 000000000..c06bdab14 --- /dev/null +++ b/test/native_download_progress_bridge_test.dart @@ -0,0 +1,141 @@ +import 'dart:async'; +import 'dart:convert'; + +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/services/platform_bridge.dart'; + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + const channel = MethodChannel('com.zarz.mornye/backend'); + const events = MethodChannel('com.zarz.mornye/download_progress_stream'); + const codec = StandardMethodCodec(); + final messenger = + TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger; + + tearDown(() { + messenger.setMockMethodCallHandler(channel, null); + messenger.setMockMethodCallHandler(events, null); + }); + + final snapshot = { + 'seq': 19, + 'reset': true, + 'run_id': 'example-run', + 'state_serial': 8, + 'compact_items': [ + for (var i = 0; i < 2000; i++) + { + 'item_id': '$i', + 'name': 'Example song $i', + 'progress': 0.5, + 'error': null, + }, + ], + 'item_ids': [for (var i = 0; i < 2000; i++) '$i'], + }; + final largeJson = jsonEncode(snapshot); + + test('large snapshots yield while decoding and retain all fields', () async { + expect(largeJson.length, greaterThanOrEqualTo(128 * 1024)); + final timer = Completer(); + messenger.setMockMethodCallHandler(channel, (call) async { + expect(call.method, 'getNativeDownloadWorkerSnapshot'); + expect(call.arguments, {'since_state_serial': 7}); + Timer.run(timer.complete); + return largeJson; + }); + final result = await PlatformBridge.getNativeDownloadWorkerSnapshot( + sinceStateSerial: 7, + ); + expect(timer.isCompleted, isTrue); + expect(result, snapshot); + await timer.future; + }); + + test( + 'snapshot maps, empty payloads and decode errors keep their contract', + () async { + for (final value in [snapshot, '', null, '[]', 'null', '{}']) { + messenger.setMockMethodCallHandler(channel, (_) async => value); + expect( + await PlatformBridge.getNativeDownloadWorkerSnapshot(), + value is Map ? snapshot : isEmpty, + ); + } + messenger.setMockMethodCallHandler(channel, (_) async => '{broken'); + await expectLater( + PlatformBridge.getNativeDownloadWorkerSnapshot(), + throwsA(isA()), + ); + }, + ); + + test( + 'progress JSON stays ordered across large payloads and errors', + () async { + final listening = Completer(); + final cancelled = Completer(); + messenger.setMockMethodCallHandler(events, (call) async { + if (call.method == 'listen') listening.complete(); + if (call.method == 'cancel') cancelled.complete(); + return null; + }); + final seen = []; + final done = Completer(); + final subscription = PlatformBridge.downloadProgressStream().listen(( + value, + ) { + seen.add(value); + if (seen.length == 4) done.complete(); + }, onError: (Object error) => seen.add(error)); + await listening.future; + for (final value in [ + largeJson, + {'seq': 20}, + '{broken', + '{"seq":21}', + ]) { + await messenger.handlePlatformMessage( + events.name, + codec.encodeSuccessEnvelope(value), + (_) {}, + ); + } + await done.future; + expect(seen[0], snapshot); + expect(seen[1], {'seq': 20}); + expect(seen[2], isA()); + expect(seen[3], {'seq': 21}); + await subscription.cancel(); + await cancelled.future; + }, + ); + + test( + 'cancelling a large progress decode retires the native stream', + () async { + final listening = Completer(); + final cancelled = Completer(); + messenger.setMockMethodCallHandler(events, (call) async { + if (call.method == 'listen') listening.complete(); + if (call.method == 'cancel') cancelled.complete(); + return null; + }); + final seen = >[]; + final subscription = PlatformBridge.downloadProgressStream().listen( + seen.add, + ); + await listening.future; + await messenger.handlePlatformMessage( + events.name, + codec.encodeSuccessEnvelope(largeJson), + (_) {}, + ); + await subscription.cancel(); + await cancelled.future; + await Future.delayed(Duration.zero); + expect(seen, isEmpty); + }, + ); +}