Add serialization and show offline chart.

STYLE.md

@@ -9,6 +9,7 @@ and some items of
 When an object owns and exposes a (listenable) value,
 more complicated than just public field
 we declare the related class members always in the same order,
+without new lines separating the members,
 in compliance with
 [Flutter repo style guide]( https://github.com/flutter/flutter/wiki/Style-guide-for-Flutter-repo#order-other-class-members-in-a-way-that-makes-sense):
 

packages/devtools_app/lib/src/screens/memory/framework/memory_controller.dart

@@ -8,6 +8,7 @@ import 'package:devtools_app_shared/utils.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/widgets.dart';
 
+import '../../../shared/globals.dart';
 import '../../../shared/memory/class_name.dart';
 import '../../../shared/memory/heap_graph_loader.dart';
 import '../../../shared/offline_data.dart';
@@ -36,20 +37,20 @@ class MemoryController extends DisposableController
     @visibleForTesting ProfilePaneController? connectedProfile,
   }) {
     if (connectedDiff != null || connectedProfile != null) {
-      _mode = DevToolsMode.connected;
+      _mode = ControllerCreationMode.connected;
     } else {
       _mode = devToolsMode;
     }
     unawaited(_init(connectedDiff, connectedProfile));
   }
 
-  Future<void> get initialized => _initialized.future;
-  final _initialized = Completer<void>();
+  Future<void> get initialized => _dataInitialized.future;
+  final _dataInitialized = Completer<void>();
 
   /// DevTools mode at the time of creation of the controller.
   ///
   /// DevTools will recreate controller when the mode changes.
-  late final DevToolsMode _mode;
+  late final ControllerCreationMode _mode;
 
   /// Index of the selected feature tab.
   ///
@@ -85,19 +86,20 @@ class MemoryController extends DisposableController
     @visibleForTesting DiffPaneController? connectedDiff,
     @visibleForTesting ProfilePaneController? connectedProfile,
   ) async {
-    assert(!_initialized.isCompleted);
+    assert(!_dataInitialized.isCompleted);
     switch (_mode) {
-      case DevToolsMode.disconnected:
+      case ControllerCreationMode.disconnected:
         // TODO(polina-c): load memory screen in disconnected mode, https://github.com/flutter/devtools/issues/6972
         _initializeData();
-      case DevToolsMode.connected:
+      case ControllerCreationMode.connected:
+        await serviceConnection.serviceManager.onServiceAvailable;
         _initializeData(
           diffPaneController: connectedDiff,
           profilePaneController: connectedProfile,
         );
-      case DevToolsMode.offlineData:
+      case ControllerCreationMode.offlineData:
         assert(connectedDiff == null && connectedProfile == null);
-        await maybeLoadOfflineData(
+        final loaded = await maybeLoadOfflineData(
           ScreenMetaData.memory.id,
           createData: (json) {
             final data = json[_jsonKey];
@@ -109,31 +111,32 @@ class MemoryController extends DisposableController
         );
         // [maybeLoadOfflineData] will be a noop if there is no offline data for the memory screen,
         //  so ensure we still call [_initializedData] if it has not been called.
-        if (!_initialized.isCompleted) _initializeData();
-        assert(_initialized.isCompleted);
+        assert(loaded == _dataInitialized.isCompleted);
+        if (!_dataInitialized.isCompleted) {
+          _initializeData();
+        }
     }
-    assert(_initialized.isCompleted);
+    assert(_dataInitialized.isCompleted);
   }
 
   void _initializeData({
     OfflineMemoryData? offlineData,
     @visibleForTesting DiffPaneController? diffPaneController,
     @visibleForTesting ProfilePaneController? profilePaneController,
   }) {
-    assert(!_initialized.isCompleted);
+    assert(!_dataInitialized.isCompleted);
 
-    chart = offlineData?.chart ?? MemoryChartPaneController(_mode);
+    chart = MemoryChartPaneController(_mode, data: offlineData?.chart);
     diff = diffPaneController ??
         offlineData?.diff ??
         DiffPaneController(
           loader: HeapGraphLoaderRuntime(chart.data.timeline),
         );
     profile = profilePaneController ??
         offlineData?.profile ??
-        ProfilePaneController();
+        ProfilePaneController(mode: _mode);
     control = MemoryControlPaneController(
       chart.data.timeline,
-      isChartVisible: chart.isChartVisible,
       exportData: exportData,
     );
     tracing = TracingPaneController();
@@ -142,24 +145,26 @@ class MemoryController extends DisposableController
     if (offlineData != null) profile.setFilter(offlineData.filter);
     _shareClassFilterBetweenProfileAndDiff();
 
-    _initialized.complete();
+    _dataInitialized.complete();
   }
 
   @override
-  OfflineScreenData prepareOfflineScreenData() => OfflineScreenData(
-        screenId: ScreenMetaData.memory.id,
-        data: {
-          // Passing serializable data without conversion to json here
-          // to skip serialization when data are passed in-process.
-          _jsonKey: OfflineMemoryData(
-            diff,
-            profile,
-            chart,
-            profile.classFilter.value,
-            selectedTab: selectedFeatureTabIndex,
-          ),
-        },
-      );
+  OfflineScreenData prepareOfflineScreenData() {
+    return OfflineScreenData(
+      screenId: ScreenMetaData.memory.id,
+      data: {
+        // Passing serializable data without conversion to json here
+        // to skip serialization when data is passed in-process.
+        _jsonKey: OfflineMemoryData(
+          diff,
+          profile,
+          chart.data,
+          profile.classFilter.value,
+          selectedTab: selectedFeatureTabIndex,
+        ),
+      },
+    );
+  }
 
   void _shareClassFilterBetweenProfileAndDiff() {
     diff.derived.applyFilter(profile.classFilter.value);

packages/devtools_app/lib/src/screens/memory/framework/offline_data/offline_data.dart

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import '../../panes/chart/controller/chart_pane_controller.dart';
+import '../../panes/chart/controller/chart_data.dart';
 import '../../panes/diff/controller/diff_pane_controller.dart';
 import '../../panes/profile/profile_pane_controller.dart';
 import '../../shared/heap/class_filter.dart';
@@ -30,7 +30,7 @@ class OfflineMemoryData {
     return OfflineMemoryData(
       DiffPaneController.fromJson(item(_Json.diffData)),
       ProfilePaneController.fromJson(item(_Json.profileData)),
-      MemoryChartPaneController.fromJson(item(_Json.chartData)),
+      ChartData.fromJson(item(_Json.chartData)),
       ClassFilter.fromJson(item(_Json.classFilter)),
       selectedTab: json[_Json.selectedTab] as int? ?? 0,
     );
@@ -41,7 +41,7 @@ class OfflineMemoryData {
 
   final DiffPaneController diff;
   final ProfilePaneController profile;
-  final MemoryChartPaneController chart;
+  final ChartData chart;
 
   Map<String, dynamic> toJson() {
     return {

packages/devtools_app/lib/src/screens/memory/panes/chart/controller/chart_connection.dart

@@ -2,12 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import 'dart:async';
-
 import 'package:devtools_app_shared/utils.dart';
 import 'package:flutter/foundation.dart';
 
 import '../../../../../shared/globals.dart';
+import '../../../../../shared/utils.dart';
 import '../../../shared/primitives/memory_timeline.dart';
 import '../data/primitives.dart';
 import 'memory_tracker.dart';
@@ -23,9 +22,9 @@ import 'memory_tracker.dart';
 ///
 /// All interactions between chart and vm are initiated by this class.
 /// So, if this class is not instantiated, the interaction does not happen.
-class ChartConnection extends DisposableController
+class ChartVmConnection extends DisposableController
     with AutoDisposeControllerMixin {
-  ChartConnection(this.timeline, {required this.isAndroidChartVisible});
+  ChartVmConnection(this.timeline, {required this.isAndroidChartVisible});
 
   final MemoryTimeline timeline;
   final ValueListenable<bool> isAndroidChartVisible;
@@ -35,36 +34,67 @@ class ChartConnection extends DisposableController
     isAndroidChartVisible: isAndroidChartVisible,
   );
 
-  Timer? _pollingTimer;
-  bool _connected = false;
+  bool initialized = false;
+
+  DebounceTimer? _polling;
+
+  late final bool isDeviceAndroid;
+
+  /// Initializes the connection.
+  ///
+  /// This method should be called without async gap after validation that
+  /// the application is still connected.
+  void init() {
+    if (initialized) return;
+
+    assert(serviceConnection.serviceManager.connectedState.value.connected);
 
-  late final isDeviceAndroid =
-      serviceConnection.serviceManager.vm?.operatingSystem == 'android';
+    isDeviceAndroid =
+        serviceConnection.serviceManager.vm?.operatingSystem == 'android';
+
+    addAutoDisposeListener(serviceConnection.serviceManager.connectedState, () {
+      final connected =
+          serviceConnection.serviceManager.connectedState.value.connected;
+      if (!connected) {
+        _polling?.cancel();
+      }
+    });
 
-  Future<void> maybeConnect() async {
-    if (_connected) return;
-    await serviceConnection.serviceManager.onServiceAvailable;
     autoDisposeStreamSubscription(
       serviceConnection.serviceManager.service!.onExtensionEvent
           .listen(_memoryTracker.onMemoryData),
     );
+
     autoDisposeStreamSubscription(
       serviceConnection.serviceManager.service!.onGCEvent
           .listen(_memoryTracker.onGCEvent),
     );
-    await _onPoll();
-    _connected = true;
-  }
 
-  Future<void> _onPoll() async {
-    _pollingTimer = null;
-    await _memoryTracker.pollMemory();
-    _pollingTimer = Timer(chartUpdateDelay, _onPoll);
+    _polling = DebounceTimer.periodic(
+      chartUpdateDelay,
+      () async {
+        if (!serviceConnection.serviceManager.connectedState.value.connected) {
+          _polling?.cancel();
+          return;
+        }
+        try {
+          await _memoryTracker.pollMemory();
+        } catch (e) {
+          if (serviceConnection.serviceManager.connectedState.value.connected) {
+            rethrow;
+          }
+        }
+      },
+    );
+
+    initialized = true;
   }
 
   @override
   void dispose() {
-    _pollingTimer?.cancel();
+    _polling?.cancel();
+    _polling?.dispose();
+    _polling = null;
     super.dispose();
   }
 }

packages/devtools_app/lib/src/screens/memory/panes/chart/controller/chart_data.dart

@@ -8,34 +8,80 @@ import '../../../../../shared/primitives/simple_items.dart';
 import '../../../shared/primitives/memory_timeline.dart';
 import '../data/primitives.dart';
 
+class _Json {
+  static const isDeviceAndroid = 'isAndroid';
+  static const timeline = 'timeline';
+  static const interval = 'interval';
+  static const isLegendVisible = 'isLegendVisible';
+}
+
 /// Chart data, that should be saved when transferred to offline data mode.
 class ChartData {
-  ChartData({required this.isDeviceAndroid});
+  ChartData({
+    required ControllerCreationMode mode,
+    this.isDeviceAndroid,
+    MemoryTimeline? timeline,
+    ChartInterval? interval,
+    bool? isLegendVisible,
+  })  : assert(
+          mode == ControllerCreationMode.connected ||
+              (mode == ControllerCreationMode.offlineData &&
+                  isDeviceAndroid != null &&
+                  timeline != null &&
+                  interval != null &&
+                  isLegendVisible != null),
+        ),
+        _displayInterval =
+            ValueNotifier<ChartInterval>(interval ?? ChartInterval.theDefault),
+        _isLegendVisible = ValueNotifier<bool>(isLegendVisible ?? true) {
+    this.timeline = timeline ?? MemoryTimeline();
+  }
+
+  factory ChartData.fromJson(Map<String, dynamic> json) {
+    final result = ChartData(
+      mode: ControllerCreationMode.offlineData,
+      isDeviceAndroid: json[_Json.isDeviceAndroid] as bool? ?? false,
+      timeline:
+          MemoryTimeline.fromJson(json[_Json.timeline] as Map<String, dynamic>),
+      interval: ChartInterval.byName(json[_Json.interval]) ??
+          ChartInterval.theDefault,
+      isLegendVisible: json[_Json.isLegendVisible] as bool?,
+    );
+    return result;
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      _Json.isDeviceAndroid: isDeviceAndroid ?? false,
+      _Json.timeline: timeline.toJson(),
+      _Json.interval: displayInterval.name,
+      _Json.isLegendVisible: isLegendVisible.value,
+    };
+  }
 
-  /// Wether device is android, if [mode] is not [DevToolsMode.connected].
+  /// Whether the device is an Android device.
   ///
-  /// If [mode] is [DevToolsMode.connected], this value is null
-  /// and chart visibility should be detected based on connected app.
-  final bool? isDeviceAndroid;
+  /// If connected to application, this value is set after the class creation,
+  /// by the instance owner.
+  bool? isDeviceAndroid;
 
-  final MemoryTimeline timeline = MemoryTimeline();
+  late final MemoryTimeline timeline;
 
   /// Default is to display default tick width based on width of chart of the collected
   /// data in the chart.
   ChartInterval get displayInterval => _displayInterval.value;
-  final _displayInterval =
-      ValueNotifier<ChartInterval>(ChartInterval.theDefault);
+  final ValueNotifier<ChartInterval> _displayInterval;
   set displayInterval(ChartInterval interval) {
     _displayInterval.value = interval;
   }
 
-  ValueListenable<bool> get isLegendVisible => _legendVisibleNotifier;
-  final _legendVisibleNotifier = ValueNotifier<bool>(true);
+  ValueListenable<bool> get isLegendVisible => _isLegendVisible;
+  late final ValueNotifier<bool> _isLegendVisible;
   bool toggleLegendVisibility() =>
-      _legendVisibleNotifier.value = !_legendVisibleNotifier.value;
+      _isLegendVisible.value = !_isLegendVisible.value;
 
   void dispose() {
     _displayInterval.dispose();
-    _legendVisibleNotifier.dispose();
+    _isLegendVisible.dispose();
   }
 }