Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.
Dart blogconfluence-alternativecontent-managementcontent-servicesdocumentationflutternote-takingnotion-alternativeproject-managementtask-managementteam-collaborationwiki
import 'package:appflowy/plugins/database/domain/database_view_service.dart';
import 'package:appflowy/plugins/database/tab_bar/tab_bar_view.dart';
import 'package:appflowy/plugins/database/widgets/database_layout_ext.dart';
import 'package:appflowy/plugins/document/presentation/compact_mode_event.dart';
import 'package:appflowy/workspace/application/view/prelude.dart';
import 'package:appflowy/workspace/application/view/view_ext.dart';
import 'package:appflowy_backend/log.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/protobuf.dart';
import 'package:appflowy_backend/protobuf/flowy-folder/view.pb.dart';
import 'package:equatable/equatable.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:freezed_annotation/freezed_annotation.dart';
import 'package:universal_platform/universal_platform.dart';
import 'database_controller.dart';
part 'tab_bar_bloc.freezed.dart';
class DatabaseTabBarBloc
extends Bloc<DatabaseTabBarEvent, DatabaseTabBarState> {
DatabaseTabBarBloc({
required ViewPB view,
required String compactModeId,
required bool enableCompactMode,
}) : super(
DatabaseTabBarState.initial(
view,
compactModeId,
enableCompactMode,
),
) {
on<DatabaseTabBarEvent>(
(event, emit) async {
await event.when(
initial: () {
_listenInlineViewChanged();
_loadChildView();
},
didLoadChildViews: (List<ViewPB> childViews) {
emit(
state.copyWith(
tabBars: [
...state.tabBars,
...childViews.map(
(newChildView) => DatabaseTabBar(view: newChildView),
),
],
tabBarControllerByViewId: _extendsTabBarController(childViews),
),
);
},
selectView: (String viewId) {
final index =
state.tabBars.indexWhere((element) => element.viewId == viewId);
if (index != -1) {
emit(
state.copyWith(selectedIndex: index),
);
}
},
createView: (layout, name) {
_createLinkedView(layout.layoutType, name ?? layout.layoutName);
},
deleteView: (String viewId) async {
final result = await ViewBackendService.deleteView(viewId: viewId);
result.fold(
(l) {},
(r) => Log.error(r),
);
},
renameView: (String viewId, String newName) {
ViewBackendService.updateView(viewId: viewId, name: newName);
},
didUpdateChildViews: (updatePB) async {
if (updatePB.createChildViews.isNotEmpty) {
final allTabBars = [
...state.tabBars,
...updatePB.createChildViews
.map((e) => DatabaseTabBar(view: e)),
];
emit(
state.copyWith(
tabBars: allTabBars,
selectedIndex: state.tabBars.length,
tabBarControllerByViewId:
_extendsTabBarController(updatePB.createChildViews),
),
);
}
if (updatePB.deleteChildViews.isNotEmpty) {
final allTabBars = [...state.tabBars];
final tabBarControllerByViewId = {
...state.tabBarControllerByViewId,
};
var newSelectedIndex = state.selectedIndex;
for (final viewId in updatePB.deleteChildViews) {
final index = allTabBars.indexWhere(
(element) => element.viewId == viewId,
);
if (index != -1) {
final tabBar = allTabBars.removeAt(index);
// Dispose the controller when the tab is removed.
final controller =
tabBarControllerByViewId.remove(tabBar.viewId);
await controller?.dispose();
}
if (index == state.selectedIndex) {
if (index > 0 && allTabBars.isNotEmpty) {
newSelectedIndex = index - 1;
}
}
}
emit(
state.copyWith(
tabBars: allTabBars,
selectedIndex: newSelectedIndex,
tabBarControllerByViewId: tabBarControllerByViewId,
),
);
}
},
viewDidUpdate: (ViewPB updatedView) {
final index = state.tabBars.indexWhere(
(element) => element.viewId == updatedView.id,
);
if (index != -1) {
final allTabBars = [...state.tabBars];
final updatedTabBar = DatabaseTabBar(view: updatedView);
allTabBars[index] = updatedTabBar;
emit(state.copyWith(tabBars: allTabBars));
}
},
);
},
);
}
@override
Future<void> close() async {
for (final tabBar in state.tabBars) {
await state.tabBarControllerByViewId[tabBar.viewId]?.dispose();
tabBar.dispose();
}
return super.close();
}
void _listenInlineViewChanged() {
final controller = state.tabBarControllerByViewId[state.parentView.id];
controller?.onViewUpdated = (newView) {
add(DatabaseTabBarEvent.viewDidUpdate(newView));
};
// Only listen the child view changes when the parent view is inline.
controller?.onViewChildViewChanged = (update) {
add(DatabaseTabBarEvent.didUpdateChildViews(update));
};
}
/// Create tab bar controllers for the new views and return the updated map.
Map<String, DatabaseTabBarController> _extendsTabBarController(
List<ViewPB> newViews,
) {
final tabBarControllerByViewId = {...state.tabBarControllerByViewId};
for (final view in newViews) {
final controller = DatabaseTabBarController(
view: view,
compactModeId: state.compactModeId,
enableCompactMode: state.enableCompactMode,
)..onViewUpdated = (newView) {
add(DatabaseTabBarEvent.viewDidUpdate(newView));
};
tabBarControllerByViewId[view.id] = controller;
}
return tabBarControllerByViewId;
}
Future<void> _createLinkedView(ViewLayoutPB layoutType, String name) async {
final viewId = state.parentView.id;
final databaseIdOrError =
await DatabaseViewBackendService(viewId: viewId).getDatabaseId();
databaseIdOrError.fold(
(databaseId) async {
final linkedViewOrError =
await ViewBackendService.createDatabaseLinkedView(
parentViewId: viewId,
databaseId: databaseId,
layoutType: layoutType,
name: name,
);
linkedViewOrError.fold(
(linkedView) {},
(err) => Log.error(err),
);
},
(r) => Log.error(r),
);
}
void _loadChildView() async {
final viewsOrFail =
await ViewBackendService.getChildViews(viewId: state.parentView.id);
viewsOrFail.fold(
(views) {
if (!isClosed) {
add(DatabaseTabBarEvent.didLoadChildViews(views));
}
},
(err) => Log.error(err),
);
}
}
@freezed
class DatabaseTabBarEvent with _$DatabaseTabBarEvent {
const factory DatabaseTabBarEvent.initial() = _Initial;
const factory DatabaseTabBarEvent.didLoadChildViews(
List<ViewPB> childViews,
) = _DidLoadChildViews;
const factory DatabaseTabBarEvent.selectView(String viewId) = _DidSelectView;
const factory DatabaseTabBarEvent.createView(
DatabaseLayoutPB layout,
String? name,
) = _CreateView;
const factory DatabaseTabBarEvent.renameView(String viewId, String newName) =
_RenameView;
const factory DatabaseTabBarEvent.deleteView(String viewId) = _DeleteView;
const factory DatabaseTabBarEvent.didUpdateChildViews(
ChildViewUpdatePB updatePB,
) = _DidUpdateChildViews;
const factory DatabaseTabBarEvent.viewDidUpdate(ViewPB view) = _ViewDidUpdate;
}
@freezed
class DatabaseTabBarState with _$DatabaseTabBarState {
const factory DatabaseTabBarState({
required ViewPB parentView,
required int selectedIndex,
required String compactModeId,
required bool enableCompactMode,
required List<DatabaseTabBar> tabBars,
required Map<String, DatabaseTabBarController> tabBarControllerByViewId,
}) = _DatabaseTabBarState;
factory DatabaseTabBarState.initial(
ViewPB view,
String compactModeId,
bool enableCompactMode,
) {
final tabBar = DatabaseTabBar(view: view);
return DatabaseTabBarState(
parentView: view,
selectedIndex: 0,
compactModeId: compactModeId,
enableCompactMode: enableCompactMode,
tabBars: [tabBar],
tabBarControllerByViewId: {
view.id: DatabaseTabBarController(
view: view,
compactModeId: compactModeId,
enableCompactMode: enableCompactMode,
),
},
);
}
}
class DatabaseTabBar extends Equatable {
DatabaseTabBar({
required this.view,
}) : _builder = UniversalPlatform.isMobile
? view.mobileTabBarItem()
: view.tabBarItem();
final ViewPB view;
final DatabaseTabBarItemBuilder _builder;
String get viewId => view.id;
DatabaseTabBarItemBuilder get builder => _builder;
ViewLayoutPB get layout => view.layout;
@override
List<Object?> get props => [view.hashCode];
void dispose() {
_builder.dispose();
}
}
typedef OnViewUpdated = void Function(ViewPB newView);
typedef OnViewChildViewChanged = void Function(
ChildViewUpdatePB childViewUpdate,
);
class DatabaseTabBarController {
DatabaseTabBarController({
required this.view,
required String compactModeId,
required bool enableCompactMode,
}) : controller = DatabaseController(view: view)
..initCompactMode(enableCompactMode)
..addListener(
onCompactModeChanged: (v) async {
compactModeEventBus
.fire(CompactModeEvent(id: compactModeId, enable: v));
},
),
viewListener = ViewListener(viewId: view.id) {
viewListener.start(
onViewChildViewsUpdated: (update) => onViewChildViewChanged?.call(update),
onViewUpdated: (newView) {
view = newView;
onViewUpdated?.call(newView);
},
);
}
ViewPB view;
final DatabaseController controller;
final ViewListener viewListener;
OnViewUpdated? onViewUpdated;
OnViewChildViewChanged? onViewChildViewChanged;
Future<void> dispose() async {
await Future.wait([viewListener.stop(), controller.dispose()]);
}
}