chore: read setting

frontend/app_flowy/lib/plugins/grid/application/cell/cell_service/cell_service.dart

@@ -21,7 +21,7 @@ import '../../field/type_option/type_option_context.dart';
 import 'cell_field_notifier.dart';
 part 'cell_service.freezed.dart';
 part 'cell_data_loader.dart';
-part 'context_builder.dart';
+part 'cell_controller.dart';
 part 'cell_cache.dart';
 part 'cell_data_persistence.dart';
 

frontend/app_flowy/lib/plugins/grid/application/field/field_cache.dart

@@ -52,9 +52,6 @@ class GridFieldCache {
     _fieldNotifier = null;
   }
 
-  UnmodifiableListView<FieldPB> get unmodifiableFields =>
-      UnmodifiableListView(_fieldNotifier?.fields ?? []);
-
   List<FieldPB> get fields => [..._fieldNotifier?.fields ?? []];
 
   set fields(List<FieldPB> fields) {
@@ -158,7 +155,8 @@ class GridRowFieldNotifierImpl extends IGridRowFieldNotifier {
   GridRowFieldNotifierImpl(GridFieldCache cache) : _cache = cache;
 
   @override
-  UnmodifiableListView<FieldPB> get fields => _cache.unmodifiableFields;
+  UnmodifiableListView<FieldPB> get fields =>
+      UnmodifiableListView(_cache.fields);
 
   @override
   void onRowFieldsChanged(VoidCallback callback) {

frontend/app_flowy/lib/plugins/grid/application/setting/group_bloc.dart

@@ -6,16 +6,19 @@ import 'package:freezed_annotation/freezed_annotation.dart';
 import 'dart:async';
 
 import '../field/field_cache.dart';
+import 'setting_controller.dart';
 
 part 'group_bloc.freezed.dart';
 
 class GridGroupBloc extends Bloc<GridGroupEvent, GridGroupState> {
   final GridFieldCache _fieldCache;
+  final SettingController _settingController;
   Function(List<FieldPB>)? _onFieldsFn;
 
-  GridGroupBloc({required String gridId, required GridFieldCache fieldCache})
+  GridGroupBloc({required String viewId, required GridFieldCache fieldCache})
       : _fieldCache = fieldCache,
-        super(GridGroupState.initial(gridId, fieldCache.fields)) {
+        _settingController = SettingController(viewId: viewId),
+        super(GridGroupState.initial(viewId, fieldCache.fields)) {
     on<GridGroupEvent>(
       (event, emit) async {
         await event.map(
@@ -24,7 +27,7 @@ class GridGroupBloc extends Bloc<GridGroupEvent, GridGroupState> {
           },
           setFieldVisibility: (_SetFieldVisibility value) async {
             final fieldService =
-                FieldService(gridId: gridId, fieldId: value.fieldId);
+                FieldService(gridId: viewId, fieldId: value.fieldId);
             final result =
                 await fieldService.updateField(visibility: value.visibility);
             result.fold(
@@ -58,6 +61,11 @@ class GridGroupBloc extends Bloc<GridGroupEvent, GridGroupState> {
       onFields: _onFieldsFn,
       listenWhen: () => !isClosed,
     );
+
+    _settingController.startListeing(
+      onSettingUpdated: (setting) {},
+      onError: (err) {},
+    );
   }
 }
 

frontend/app_flowy/lib/plugins/grid/application/setting/setting_controller.dart

@@ -0,0 +1,58 @@
+import 'package:app_flowy/plugins/grid/application/setting/setting_service.dart';
+import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
+import 'package:flowy_sdk/protobuf/flowy-grid/setting_entities.pb.dart';
+import 'setting_listener.dart';
+
+typedef OnError = void Function(FlowyError);
+typedef OnSettingUpdated = void Function(GridSettingPB);
+
+class SettingController {
+  final String viewId;
+  final SettingFFIService _ffiService;
+  final SettingListener _listener;
+  OnSettingUpdated? _onSettingUpdated;
+  OnError? _onError;
+  GridSettingPB? _setting;
+  GridSettingPB? get setting => _setting;
+
+  SettingController({
+    required this.viewId,
+  })  : _ffiService = SettingFFIService(viewId: viewId),
+        _listener = SettingListener(gridId: viewId) {
+    // Load setting
+    _ffiService.getSetting().then((result) {
+      result.fold(
+        (newSetting) => updateSetting(newSetting),
+        (err) => _onError?.call(err),
+      );
+    });
+
+    // Listen on the seting changes
+    _listener.start(onSettingUpdated: (result) {
+      result.fold(
+        (newSetting) => updateSetting(newSetting),
+        (err) => _onError?.call(err),
+      );
+    });
+  }
+
+  void startListeing({
+    required OnSettingUpdated onSettingUpdated,
+    required OnError onError,
+  }) {
+    assert(_onSettingUpdated == null, 'Should call once');
+    _onSettingUpdated = onSettingUpdated;
+    _onError = onError;
+  }
+
+  void updateSetting(GridSettingPB newSetting) {
+    _setting = newSetting;
+    _onSettingUpdated?.call(newSetting);
+  }
+
+  void dispose() {
+    _onSettingUpdated = null;
+    _onError = null;
+    _listener.stop();
+  }
+}

frontend/app_flowy/lib/plugins/grid/application/setting/setting_listener.dart

@@ -0,0 +1,47 @@
+import 'dart:typed_data';
+
+import 'package:app_flowy/core/grid_notification.dart';
+import 'package:dartz/dartz.dart';
+import 'package:flowy_infra/notifier.dart';
+import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
+import 'package:flowy_sdk/protobuf/flowy-grid/dart_notification.pbserver.dart';
+import 'package:flowy_sdk/protobuf/flowy-grid/setting_entities.pb.dart';
+
+typedef UpdateSettingNotifiedValue = Either<GridSettingPB, FlowyError>;
+
+class SettingListener {
+  final String gridId;
+  GridNotificationListener? _listener;
+  PublishNotifier<UpdateSettingNotifiedValue>? _updateSettingNotifier =
+      PublishNotifier();
+
+  SettingListener({required this.gridId});
+
+  void start({
+    required void Function(UpdateSettingNotifiedValue) onSettingUpdated,
+  }) {
+    _updateSettingNotifier?.addPublishListener(onSettingUpdated);
+    _listener = GridNotificationListener(objectId: gridId, handler: _handler);
+  }
+
+  void _handler(GridNotification ty, Either<Uint8List, FlowyError> result) {
+    switch (ty) {
+      case GridNotification.DidUpdateGridSetting:
+        result.fold(
+          (payload) => _updateSettingNotifier?.value = left(
+            GridSettingPB.fromBuffer(payload),
+          ),
+          (error) => _updateSettingNotifier?.value = right(error),
+        );
+        break;
+      default:
+        break;
+    }
+  }
+
+  Future<void> stop() async {
+    await _listener?.stop();
+    _updateSettingNotifier?.dispose();
+    _updateSettingNotifier = null;
+  }
+}

frontend/app_flowy/lib/plugins/grid/application/setting/setting_service.dart

@@ -0,0 +1,16 @@
+import 'package:dartz/dartz.dart';
+import 'package:flowy_sdk/dispatch/dispatch.dart';
+import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
+import 'package:flowy_sdk/protobuf/flowy-grid/grid_entities.pb.dart';
+import 'package:flowy_sdk/protobuf/flowy-grid/setting_entities.pb.dart';
+
+class SettingFFIService {
+  final String viewId;
+
+  const SettingFFIService({required this.viewId});
+
+  Future<Either<GridSettingPB, FlowyError>> getSetting() {
+    final payload = GridIdPB.create()..value = viewId;
+    return GridEventGetGridSetting(payload).send();
+  }
+}

frontend/app_flowy/lib/plugins/grid/presentation/widgets/toolbar/grid_group.dart

@@ -1,17 +1,11 @@
 import 'package:app_flowy/plugins/grid/application/field/field_cache.dart';
-<<<<<<< HEAD
-=======
 import 'package:app_flowy/plugins/grid/presentation/layout/sizes.dart';
->>>>>>> 0e1004785 (chore: config switch group field UI)
 import 'package:app_flowy/plugins/grid/presentation/widgets/header/field_type_extension.dart';
 import 'package:flowy_infra/image.dart';
 import 'package:flowy_infra/theme.dart';
 import 'package:flowy_infra_ui/style_widget/button.dart';
 import 'package:flowy_infra_ui/style_widget/text.dart';
-<<<<<<< HEAD
-=======
 import 'package:flowy_infra_ui/widget/spacing.dart';
->>>>>>> 0e1004785 (chore: config switch group field UI)
 import 'package:flowy_sdk/protobuf/flowy-grid/field_entities.pb.dart';
 import 'package:flutter/material.dart';
 import 'package:app_flowy/plugins/grid/application/setting/group_bloc.dart';
@@ -30,8 +24,10 @@ class GridGroupList extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return BlocProvider(
-      create: (context) => GridGroupBloc(gridId: viewId, fieldCache: fieldCache)
+      create: (context) => GridGroupBloc(
-        ..add(const GridGroupEvent.initial()),
+        viewId: viewId,
+        fieldCache: fieldCache,
+      )..add(const GridGroupEvent.initial()),
       child: BlocBuilder<GridGroupBloc, GridGroupState>(
         builder: (context, state) {
           final cells = state.fields.map((field) {

frontend/rust-lib/flowy-grid/src/dart_notification.rs

@@ -14,6 +14,7 @@ pub enum GridNotification {
     DidUpdateGroupView = 60,
     DidUpdateGroup = 61,
     DidGroupByNewField = 62,
+    DidUpdateGridSetting = 70,
 }
 
 impl std::default::Default for GridNotification {

frontend/rust-lib/flowy-grid/src/entities/filter_entities/util.rs

@@ -10,33 +10,33 @@ use std::convert::TryInto;
 use std::sync::Arc;
 
 #[derive(Eq, PartialEq, ProtoBuf, Debug, Default, Clone)]
-pub struct GridFilterConfiguration {
+pub struct GridFilterConfigurationPB {
     #[pb(index = 1)]
     pub id: String,
 }
 
 #[derive(Eq, PartialEq, ProtoBuf, Debug, Default, Clone)]
-pub struct RepeatedGridConfigurationFilterPB {
+pub struct RepeatedGridFilterConfigurationPB {
     #[pb(index = 1)]
-    pub items: Vec<GridFilterConfiguration>,
+    pub items: Vec<GridFilterConfigurationPB>,
 }
 
-impl std::convert::From<&FilterConfigurationRevision> for GridFilterConfiguration {
+impl std::convert::From<&FilterConfigurationRevision> for GridFilterConfigurationPB {
     fn from(rev: &FilterConfigurationRevision) -> Self {
         Self { id: rev.id.clone() }
     }
 }
 
-impl std::convert::From<Vec<Arc<FilterConfigurationRevision>>> for RepeatedGridConfigurationFilterPB {
+impl std::convert::From<Vec<Arc<FilterConfigurationRevision>>> for RepeatedGridFilterConfigurationPB {
     fn from(revs: Vec<Arc<FilterConfigurationRevision>>) -> Self {
-        RepeatedGridConfigurationFilterPB {
+        RepeatedGridFilterConfigurationPB {
             items: revs.into_iter().map(|rev| rev.as_ref().into()).collect(),
         }
     }
 }
 
-impl std::convert::From<Vec<GridFilterConfiguration>> for RepeatedGridConfigurationFilterPB {
+impl std::convert::From<Vec<GridFilterConfigurationPB>> for RepeatedGridFilterConfigurationPB {
-    fn from(items: Vec<GridFilterConfiguration>) -> Self {
+    fn from(items: Vec<GridFilterConfigurationPB>) -> Self {
         Self { items }
     }
 }

frontend/rust-lib/flowy-grid/src/entities/setting_entities.rs

@@ -1,6 +1,6 @@
 use crate::entities::{
     CreatGroupParams, CreateFilterParams, CreateGridFilterPayloadPB, CreateGridGroupPayloadPB, DeleteFilterParams,
-    DeleteFilterPayloadPB, DeleteGroupParams, DeleteGroupPayloadPB, RepeatedGridConfigurationFilterPB,
+    DeleteFilterPayloadPB, DeleteGroupParams, DeleteGroupPayloadPB, RepeatedGridFilterConfigurationPB,
     RepeatedGridGroupConfigurationPB,
 };
 use flowy_derive::{ProtoBuf, ProtoBuf_Enum};
@@ -19,10 +19,10 @@ pub struct GridSettingPB {
     pub layouts: Vec<GridLayoutPB>,
 
     #[pb(index = 2)]
-    pub current_layout_type: GridLayout,
+    pub layout_type: GridLayout,
 
     #[pb(index = 3)]
-    pub filter_configuration_by_field_id: HashMap<String, RepeatedGridConfigurationFilterPB>,
+    pub filter_configurations: RepeatedGridFilterConfigurationPB,
 
     #[pb(index = 4)]
     pub group_configurations: RepeatedGridGroupConfigurationPB,

frontend/rust-lib/flowy-grid/src/services/grid_editor.rs

@@ -532,7 +532,7 @@ impl GridRevisionEditor {
         self.view_manager.get_setting().await
     }
 
-    pub async fn get_grid_filter(&self) -> FlowyResult<Vec<GridFilterConfiguration>> {
+    pub async fn get_grid_filter(&self) -> FlowyResult<Vec<GridFilterConfigurationPB>> {
         self.view_manager.get_filters().await
     }
 

frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs

@@ -1,8 +1,8 @@
 use crate::dart_notification::{send_dart_notification, GridNotification};
 use crate::entities::{
-    CreateFilterParams, CreateRowParams, DeleteFilterParams, GridFilterConfiguration, GridLayout, GridLayoutPB,
+    CreateFilterParams, CreateRowParams, DeleteFilterParams, GridFilterConfigurationPB, GridGroupConfigurationPB,
-    GridSettingPB, GroupChangesetPB, GroupPB, GroupViewChangesetPB, InsertedGroupPB, InsertedRowPB, MoveGroupParams,
+    GridLayout, GridLayoutPB, GridSettingPB, GroupChangesetPB, GroupPB, GroupViewChangesetPB, InsertedGroupPB,
-    RepeatedGridConfigurationFilterPB, RepeatedGridGroupConfigurationPB, RowPB,
+    InsertedRowPB, MoveGroupParams, RepeatedGridFilterConfigurationPB, RepeatedGridGroupConfigurationPB, RowPB,
 };
 use crate::services::grid_editor_task::GridServiceTaskScheduler;
 use crate::services::grid_view_manager::{GridViewFieldDelegate, GridViewRowDelegate};
@@ -198,14 +198,14 @@ impl GridViewRevisionEditor {
         grid_setting
     }
 
-    pub(crate) async fn get_filters(&self) -> Vec<GridFilterConfiguration> {
+    pub(crate) async fn get_filters(&self) -> Vec<GridFilterConfigurationPB> {
         let field_revs = self.field_delegate.get_field_revs().await;
         match self.pad.read().await.get_all_filters(&field_revs) {
             None => vec![],
             Some(filters) => filters
                 .into_values()
                 .flatten()
-                .map(|filter| GridFilterConfiguration::from(filter.as_ref()))
+                .map(|filter| GridFilterConfigurationPB::from(filter.as_ref()))
                 .collect(),
         }
     }
@@ -463,31 +463,40 @@ impl GroupConfigurationWriter for GroupConfigurationWriterImpl {
 }
 
 pub fn make_grid_setting(view_pad: &GridViewRevisionPad, field_revs: &[Arc<FieldRevision>]) -> GridSettingPB {
-    let current_layout_type: GridLayout = view_pad.layout.clone().into();
+    let layout_type: GridLayout = view_pad.layout.clone().into();
-    let filter_configuration_by_field_id = view_pad
+    let filter_configurations = view_pad
         .get_all_filters(field_revs)
         .map(|filters_by_field_id| {
             filters_by_field_id
                 .into_iter()
-                .map(|(k, v)| (k, v.into()))
+                .map(|(_, v)| {
-                .collect::<HashMap<String, RepeatedGridConfigurationFilterPB>>()
+                    let repeated_filter: RepeatedGridFilterConfigurationPB = v.into();
+                    repeated_filter.items
+                })
+                .flatten()
+                .collect::<Vec<GridFilterConfigurationPB>>()
         })
         .unwrap_or_default();
+
     let group_configurations = view_pad
         .get_groups_by_field_revs(field_revs)
         .map(|groups_by_field_id| {
             groups_by_field_id
                 .into_iter()
-                .map(|(_, v)| v.into())
+                .map(|(_, v)| {
-                .collect::<RepeatedGridGroupConfigurationPB>()
+                    let repeated_group: RepeatedGridGroupConfigurationPB = v.into();
+                    repeated_group.items
+                })
+                .flatten()
+                .collect::<Vec<GridGroupConfigurationPB>>()
         })
         .unwrap_or_default();
 
     GridSettingPB {
         layouts: GridLayoutPB::all(),
-        current_layout_type,
+        layout_type,
-        filter_configuration_by_field_id,
+        filter_configurations: filter_configurations.into(),
-        group_configurations,
+        group_configurations: group_configurations.into(),
     }
 }
 

frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs

@@ -1,5 +1,5 @@
 use crate::entities::{
-    CreateFilterParams, CreateRowParams, DeleteFilterParams, GridFilterConfiguration, GridSettingPB, MoveGroupParams,
+    CreateFilterParams, CreateRowParams, DeleteFilterParams, GridFilterConfigurationPB, GridSettingPB, MoveGroupParams,
     RepeatedGridGroupPB, RowPB,
 };
 use crate::manager::GridUser;
@@ -105,7 +105,7 @@ impl GridViewManager {
         Ok(view_editor.get_setting().await)
     }
 
-    pub(crate) async fn get_filters(&self) -> FlowyResult<Vec<GridFilterConfiguration>> {
+    pub(crate) async fn get_filters(&self) -> FlowyResult<Vec<GridFilterConfigurationPB>> {
         let view_editor = self.get_default_view_editor().await?;
         Ok(view_editor.get_filters().await)
     }

frontend/rust-lib/flowy-grid/tests/grid/grid_editor.rs

@@ -85,7 +85,7 @@ impl GridEditorTest {
             .row_revs
     }
 
-    pub async fn grid_filters(&self) -> Vec<GridFilterConfiguration> {
+    pub async fn grid_filters(&self) -> Vec<GridFilterConfigurationPB> {
         self.editor.get_grid_filter().await.unwrap()
     }