Initial commit: COPILOT D6 Flutter keyboard controller

Flutter web app replacing legacy WPF CCTV surveillance keyboard controller.
Includes wall overview, section view with monitor grid, camera input,
PTZ control, alarm/lock/sequence BLoCs, and legacy-matching UI styling.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

copilot_keyboard/lib/injection_container.dart

@@ -0,0 +1,123 @@
+import 'package:get_it/get_it.dart';
+
+import 'config/app_config.dart';
+import 'data/services/bridge_service.dart';
+import 'data/services/alarm_service.dart';
+import 'data/services/coordination_service.dart';
+import 'data/services/function_button_service.dart';
+import 'data/services/state_service.dart';
+import 'presentation/blocs/connection/connection_bloc.dart';
+import 'presentation/blocs/camera/camera_bloc.dart';
+import 'presentation/blocs/monitor/monitor_bloc.dart';
+import 'presentation/blocs/ptz/ptz_bloc.dart';
+import 'presentation/blocs/alarm/alarm_bloc.dart';
+import 'presentation/blocs/lock/lock_bloc.dart';
+import 'presentation/blocs/sequence/sequence_bloc.dart';
+import 'presentation/blocs/wall/wall_bloc.dart';
+
+final sl = GetIt.instance;
+
+/// Initialize all dependencies
+Future<void> initializeDependencies() async {
+  // Config
+  final config = await AppConfig.load();
+  sl.registerSingleton<AppConfig>(config);
+
+  // Services
+  sl.registerLazySingleton<BridgeService>(() => BridgeService());
+  sl.registerLazySingleton<AlarmService>(() => AlarmService());
+  sl.registerLazySingleton<StateService>(() => StateService(
+        bridgeService: sl<BridgeService>(),
+        alarmService: sl<AlarmService>(),
+      ));
+  sl.registerLazySingleton<CoordinationService>(() => CoordinationService());
+  sl.registerLazySingleton<FunctionButtonService>(() => FunctionButtonService(
+        bridgeService: sl<BridgeService>(),
+        coordinationService: sl<CoordinationService>(),
+      ));
+
+  // BLoCs
+  sl.registerFactory<ConnectionBloc>(() => ConnectionBloc(
+        bridgeService: sl<BridgeService>(),
+        config: sl<AppConfig>(),
+      ));
+
+  sl.registerFactory<CameraBloc>(() => CameraBloc(
+        bridgeService: sl<BridgeService>(),
+        config: sl<AppConfig>(),
+      ));
+
+  sl.registerFactory<MonitorBloc>(() => MonitorBloc(
+        stateService: sl<StateService>(),
+        config: sl<AppConfig>(),
+      ));
+
+  sl.registerFactory<PtzBloc>(() => PtzBloc(
+        bridgeService: sl<BridgeService>(),
+        coordinationService: sl<CoordinationService>(),
+      ));
+
+  sl.registerFactory<AlarmBloc>(() => AlarmBloc(
+        alarmService: sl<AlarmService>(),
+        stateService: sl<StateService>(),
+      ));
+
+  sl.registerFactory<LockBloc>(() => LockBloc(
+        coordinationService: sl<CoordinationService>(),
+        keyboardId: sl<AppConfig>().keyboardId,
+      ));
+
+  sl.registerFactory<SequenceBloc>(() => SequenceBloc(
+        coordinationService: sl<CoordinationService>(),
+      ));
+
+  sl.registerFactory<WallBloc>(() => WallBloc(
+        bridgeService: sl<BridgeService>(),
+      ));
+}
+
+/// Initialize services (call after dependencies are set up)
+Future<void> initializeServices() async {
+  final config = sl<AppConfig>();
+  final bridgeService = sl<BridgeService>();
+  final alarmService = sl<AlarmService>();
+  final stateService = sl<StateService>();
+
+  final coordinationService = sl<CoordinationService>();
+
+  // Initialize services with config
+  await bridgeService.initialize(config.servers);
+  await alarmService.initialize(config.servers);
+  await stateService.initialize();
+  await coordinationService.initialize(config.coordinatorUrl, config.keyboardId);
+
+  // Load function button config
+  sl<FunctionButtonService>().loadConfig(config.functionButtons);
+
+  // Wire reconnection callback: resync state when a bridge comes back online
+  bridgeService.onReconnected = (serverId) {
+    stateService.syncFromBridges();
+  };
+
+  // Connect to all bridges
+  await bridgeService.connectAll();
+
+  // Sync initial state
+  await stateService.syncFromBridges();
+
+  // Start periodic alarm sync
+  alarmService.startPeriodicSync(
+    Duration(seconds: config.alarmSyncIntervalSeconds),
+  );
+
+  // Connect to coordinator (non-blocking, auto-reconnects)
+  coordinationService.connect();
+}
+
+/// Dispose all services
+void disposeServices() {
+  sl<CoordinationService>().dispose();
+  sl<AlarmService>().dispose();
+  sl<StateService>().dispose();
+  sl<BridgeService>().dispose();
+}