first commit

2025-09-24 14:08:54 +08:00
commit 40784642cf
83 changed files with 37832 additions and 0 deletions
--- a/app_car/app_car.md
+++ b/app_car/app_car.md
@@ -0,0 +1,934 @@
+# App Car - 车辆控制主模块文档
+
+## 模块概述
+
+`app_car` 是 OneApp 车辆功能的核心模块，提供完整的车辆控制、状态监控、远程操作等功能。该模块集成了车联网通信、车辆状态管理、空调控制、车门锁控制、充电管理等核心车辆服务。
+
+### 基本信息
+- **模块名称**: app_car
+- **版本**: 0.6.48+4
+- **仓库**: https://gitlab-rd0.maezia.com/dssomobile/oneapp/dssomobile-oneapp-car-app
+- **Flutter 版本**: >=3.0.0
+- **Dart 版本**: >=3.0.0 <4.0.0
+
+## 目录结构
+
+```
+app_car/
+├── lib/
+│   ├── app_car.dart              # 主导出文件
+│   ├── app_car_temp.dart         # 临时配置文件
+│   ├── generated/                # 代码生成文件
+│   ├── l10n/                     # 国际化文件
+│   └── src/                      # 源代码目录
+│       ├── ai_chat/              # AI 聊天集成
+│       ├── app_ingeek_mdk/       # 车钥匙 MDK 集成
+│       ├── bloc/                 # 状态管理（BLoC）
+│       ├── car_animation/        # 车辆动画效果
+│       ├── car_charging_center/  # 充电中心功能
+│       ├── car_charging_profiles/# 充电配置文件
+│       ├── car_climatisation/    # 空调控制
+│       ├── car_climatisation_50/ # 空调控制（5.0版本）
+│       ├── car_common_widget/    # 车辆通用组件
+│       ├── car_digital_key_renewal/# 数字钥匙更新
+│       ├── car_enum/             # 车辆相关枚举
+│       ├── car_finder_card/      # 车辆查找卡片
+│       ├── car_health_status/    # 车辆健康状态
+│       ├── car_lock_unlock/      # 车门锁控制
+│       ├── car_vehicle_status/   # 车辆状态管理
+│       ├── constants/            # 常量定义
+│       ├── dbr_card/             # DBR 卡片组件
+│       ├── models/               # 数据模型
+│       ├── pages/                # 页面组件
+│       ├── res/                  # 资源文件
+│       ├── utils/                # 工具类
+│       ├── common_import.dart    # 通用导入
+│       ├── route_dp.dart         # 路由配置
+│       └── route_export.dart     # 路由导出
+├── assets/                       # 静态资源
+├── pubspec.yaml                  # 依赖配置
+└── README.md                     # 项目说明
+```
+
+## 核心功能模块
+
+### 1. 车辆控制核心 (Vehicle Control Core)
+
+基于真实的OneApp项目实现，使用统一的Vehicle服务和BLoC状态管理。
+
+#### 远程车辆状态管理 (`bloc/home/bloc_rvs.dart`)
+```dart
+// 实际的远程车辆状态BLoC
+class RemoteVehicleStateBloc
+    extends Bloc<RemoteVehicleStateEvent, RemoteVehicleState> {
+  
+  RemoteVehicleStateBloc(
+    RvsService rvs,
+    ClimatizationService climatization,
+    int index,
+    String? noticeVin,
+    BuildContext? context,
+  ) : super(
+          RemoteVehicleState(
+            rvs: rvs,
+            climatization: climatization,
+            index: index,
+            isRefreshing: false,
+          ),
+        ) {
+    on<EnterManualRefreshEvent>(_onEnterManualRefreshEvent);
+    on<ExecuteManualRefreshEvent>(_onExecuteManualRefreshEvent);
+    on<ConditionerEvent>(_conditionerEvent);
+    on<LockEvent>(_lockEvent);
+    on<UnlockEvent>(_unlockEvent);
+    on<VehicleOverallStatusEvent>(_vehicleOverallStatusEvent);
+
+    // 检查权限
+    checkPermission();
+    
+    // 首次进来的时候获取默认车辆信息更新到Vehicle
+    Vehicle.updateUserVehicleInfo(VehicleUtils.assembleDefaultVehicleLocal());
+    
+    // 拉取页面数据
+    refreshHomeData(RvsAction.refresh);
+  }
+}
+
+// 实际的远程车辆状态数据模型
+@freezed
+class RemoteVehicleState with _$RemoteVehicleState {
+  const factory RemoteVehicleState({
+    required RvsService rvs,
+    required ClimatizationService climatization,
+    required int index,
+    required bool isRefreshing,
+    VehicleRemoteStatus? status,
+    double? temperature,
+    ClimatisationStatus? climatisationStatus,
+    ClimatizationParameter? cParameter,
+    bool? actionStart,
+    bool? actionStop,
+    bool? actionSetting,
+    bool? actionLock,
+    RluLockState? lockState,
+    CfMessage? cfMessage,
+    bool? locationPermission,
+    bool? isLocationOpen,
+    double? distance,
+    String? searchGeocode,
+    VhrWarningListMessage? primitiveVhrWarningListMessage,
+    List<HealthStatus>? vhrWarningListMessage,
+    List<VehicleDto>? vehicleDtos,
+  }) = _RemoteVehicleState;
+}
+```
+
+#### 车辆服务观察者模式
+```dart
+// 实际的车辆服务监听机制
+class Vehicle {
+  /// 添加服务观察者
+  static ObserverClient addServiceObserver(
+    ServiceType serviceType,
+    Function(UpdateEvent event, ConnectorAction action, dynamic value) callback,
+  ) {
+    return ServiceUtils.getServiceByType(serviceType)?.addObserver(callback);
+  }
+  
+  /// 更新用户车辆信息
+  static void updateUserVehicleInfo(VehicleDto? vehicleDto) {
+    if (vehicleDto != null) {
+      _currentVehicle = vehicleDto;
+    }
+  }
+}
+```
+
+### 2. 车辆状态管理 (`car_vehicle_status/`)
+
+#### 实时状态监控
+```dart
+// 车辆状态管理器
+class VehicleStatusManager {
+  Stream<VehicleStatus> get statusStream => _statusController.stream;
+  
+  final StreamController<VehicleStatus> _statusController = 
+      StreamController.broadcast();
+  
+  // 启动状态监控
+  void startStatusMonitoring() {
+    _statusTimer = Timer.periodic(
+      Duration(seconds: 30),
+      (_) => _fetchVehicleStatus(),
+    );
+  }
+  
+  Future<void> _fetchVehicleStatus() async {
+    try {
+      final status = await _vehicleConnector.getVehicleStatus();
+      status.fold(
+        (failure) => _handleStatusError(failure),
+        (vehicleStatus) => _statusController.add(vehicleStatus),
+      );
+    } catch (e) {
+      _handleStatusError(VehicleFailure.networkError(e.toString()));
+    }
+  }
+}
+```
+
+#### 车辆健康状态 (`car_health_status/`)
+```dart
+// 车辆健康状态模型
+class VehicleHealthStatus {
+  final BatteryHealth batteryHealth;
+  final EngineHealth engineHealth;
+  final List<MaintenanceAlert> maintenanceAlerts;
+  final List<DiagnosticCode> diagnosticCodes;
+  final DateTime lastCheckTime;
+  
+  const VehicleHealthStatus({
+    required this.batteryHealth,
+    required this.engineHealth,
+    required this.maintenanceAlerts,
+    required this.diagnosticCodes,
+    required this.lastCheckTime,
+  });
+  
+  // 获取整体健康评分
+  HealthScore get overallScore {
+    final scores = [
+      batteryHealth.score,
+      engineHealth.score,
+    ];
+    final average = scores.reduce((a, b) => a + b) / scores.length;
+    return HealthScore.fromValue(average);
+  }
+}
+```
+
+### 3. 充电管理 (`car_charging_center/`, `car_charging_profiles/`)
+
+基于真实项目的充电管理实现，使用Vehicle服务和ChargingOverall状态模型。
+
+#### 充电中心控制 (`car_charging_center_bloc.dart`)
+```dart
+// 实际的充电中心BLoC
+class CarChargingCenterBloc
+    extends Bloc<CarChargingCenterEvent, CarChargingCenterState> {
+  
+  CarChargingCenterBloc() : super(const CarChargingCenterState()) {
+    on<RefreshChargingEvent>(_refreshChargingEvent);
+    on<CarChargingCenterClearEvent>(_chargingCenterClearEvent);
+
+    // 注册充电服务
+    chargingService();
+
+    // 先获取内存中的值进行显示
+    final cService = ServiceUtils.getChargingService();
+    final ChargingOverall? cs =
+        cService.status == null ? null : cService.status as ChargingOverall;
+    emit(state.copyWith(chargingOverall: cs));
+
+    // 刷新充电数据
+    add(const CarChargingCenterEvent.refreshCharging());
+  }
+
+  /// 充电服务观察者
+  ObserverClient? chargingClient;
+
+  /// 充电服务监听
+  void chargingService() {
+    chargingClient = Vehicle.addServiceObserver(
+      ServiceType.remoteCharging,
+      (UpdateEvent event, ConnectorAction action, dynamic value) {
+        if (event == UpdateEvent.onStatusChange) {
+          if (value != null) {
+            final chargingOverall = value as ChargingOverall;
+            emit(state.copyWith(chargingOverall: chargingOverall));
+          }
+        }
+      },
+    );
+  }
+}
+
+// 实际的充电状态模型
+@freezed
+class CarChargingCenterState with _$CarChargingCenterState {
+  const factory CarChargingCenterState({
+    ChargingOverall? chargingOverall,
+    bool? isRefreshing,
+  }) = _CarChargingCenterState;
+}
+```
+
+#### 充电配置文件管理 (`car_charging_profiles_bloc.dart`)
+```dart
+// 实际的充电配置BLoC
+class CarChargingProfilesBloc
+    extends Bloc<CarChargingProfilesEvent, CarChargingProfilesState> {
+  
+  CarChargingProfilesBloc() : super(const CarChargingProfilesState()) {
+    on<CarChargingProfilesRefreshEvent>(_refreshEvent);
+    on<CarChargingProfilesDeleteEvent>(_deleteEvent);
+    
+    // 注册服务监听
+    chargingProfilesService();
+    
+    // 首次加载配置文件列表
+    add(const CarChargingProfilesEvent.refreshEvent());
+  }
+
+  /// 充电配置服务
+  void chargingProfilesService() {
+    chargingClient = Vehicle.addServiceObserver(
+      ServiceType.remoteCharging,
+      (UpdateEvent event, ConnectorAction action, dynamic value) {
+        if (event == UpdateEvent.onStatusChange) {
+          // 处理充电配置状态变更
+          _handleChargingProfilesUpdate(value);
+        }
+      },
+    );
+  }
+}
+```
+
+### 4. 数字钥匙管理 (`car_digital_key_renewal/`, `app_ingeek_mdk/`)
+
+#### 数字钥匙服务
+```dart
+// 数字钥匙管理服务
+class DigitalKeyService {
+  // 数字钥匙续期
+  Future<Result<void>> renewDigitalKey() async {
+    try {
+      final result = await _ingeekMdk.renewKey();
+      if (result.isSuccess) {
+        await _updateLocalKeyInfo(result.keyInfo);
+        return Right(unit);
+      } else {
+        return Left(DigitalKeyFailure.renewalFailed(result.error));
+      }
+    } catch (e) {
+      return Left(DigitalKeyFailure.networkError(e.toString()));
+    }
+  }
+  
+  // 检查钥匙状态
+  Future<Result<DigitalKeyStatus>> checkKeyStatus() async {
+    try {
+      final keyInfo = await _ingeekMdk.getKeyInfo();
+      return Right(DigitalKeyStatus.fromKeyInfo(keyInfo));
+    } catch (e) {
+      return Left(DigitalKeyFailure.statusCheckFailed(e.toString()));
+    }
+  }
+  
+  // 激活数字钥匙
+  Future<Result<void>> activateDigitalKey(String activationCode) async {
+    return await _ingeekMdk.activateKey(activationCode);
+  }
+}
+```
+
+### 5. 车辆查找功能 (`car_finder_card/`)
+
+#### 车辆定位服务
+```dart
+// 车辆查找服务
+class CarFinderService {
+  // 获取车辆位置
+  Future<Result<VehicleLocation>> getVehicleLocation() async {
+    return await _vehicleConnector.getVehicleLocation();
+  }
+  
+  // 闪灯鸣笛
+  Future<Result<void>> flashAndHonk() async {
+    return await _vehicleConnector.sendCommand(
+      VehicleCommand.flashAndHonk(),
+    );
+  }
+  
+  // 计算到车辆的距离
+  Future<Result<Distance>> calculateDistanceToVehicle(
+    UserLocation userLocation,
+  ) async {
+    final vehicleLocationResult = await getVehicleLocation();
+    return vehicleLocationResult.map((vehicleLocation) {
+      return Distance.calculate(userLocation, vehicleLocation.coordinates);
+    });
+  }
+}
+```
+
+## 状态管理架构 (`bloc/`)
+
+基于真实项目的BLoC架构和Flutter Modular依赖注入框架。
+
+### 模块化架构实现
+```dart
+// 实际的车辆控制模块（app_car.dart）
+class CarControlModule extends Module with RouteObjProvider {
+  @override
+  List<Module> get imports => [];
+
+  @override
+  List<Bind> get binds => [
+        Bind<CarBloc>((i) => CarBloc(), export: true),
+      ];
+
+  @override
+  List<ModularRoute> get routes {
+    final r1 = RouteCenterAPI.routeMetaBy(CarControlRouteExport.keyHome);
+    final r2 = RouteCenterAPI.routeMetaBy(CarControlRouteExport.keyClimatization);
+    final r3 = RouteCenterAPI.routeMetaBy(CarControlRouteExport.keyCharging);
+    final r4 = RouteCenterAPI.routeMetaBy(CarControlRouteExport.keyChargingProfile);
+    // ... 更多路由配置
+    
+    return [
+      ChildRoute(r1.path, child: (_, args) => r1.provider(args).as()),
+      ChildRoute(r2.path, child: (_, args) => r2.provider(args).as()),
+      ChildRoute(r3.path, child: (_, args) => r3.provider(args).as()),
+      ChildRoute(r4.path, child: (_, args) => r4.provider(args).as()),
+      // ... 更多路由实现
+    ];
+  }
+}
+
+// 实际的CarBloc实现
+class CarBloc extends Bloc<CarEvent, CarState> {
+  CarBloc() : super(CarState().getInstance()) {
+    on<CarEvent>((event, emit) {
+      // 处理车辆相关事件
+    });
+  }
+}
+```
+
+### 车辆状态BLoC实现
+```dart
+// 实际的车辆状态管理BLoC
+class CarVehicleBloc extends Bloc<CarVehicleEvent, CarVehicleState> {
+  CarVehicleBloc() : super(const CarVehicleState()) {
+    on<CarVehicleInitEvent>(_initEvent);
+    on<CarVehicleRefreshEvent>(_refreshEvent);
+    
+    // 初始化车辆服务
+    initVehicleService();
+  }
+  
+  void initVehicleService() {
+    // 注册车辆状态观察者
+    Vehicle.addServiceObserver(
+      ServiceType.remoteVehicleStatus,
+      (UpdateEvent event, ConnectorAction action, dynamic value) {
+        if (event == UpdateEvent.onStatusChange) {
+          final status = value as VehicleRemoteStatus;
+          emit(state.copyWith(vehicleStatus: status));
+        }
+      },
+    );
+  }
+}
+```
+
+## 数据模型 (`models/`)
+
+### 车辆状态模型
+```dart
+// 车辆状态模型
+class VehicleStatus {
+  final String vehicleId;
+  final LockStatus lockStatus;
+  final BatteryStatus batteryStatus;
+  final ClimatisationStatus climatisationStatus;
+  final ChargingStatus chargingStatus;
+  final VehicleLocation? location;
+  final DateTime lastUpdated;
+  
+  const VehicleStatus({
+    required this.vehicleId,
+    required this.lockStatus,
+    required this.batteryStatus,
+    required this.climatisationStatus,
+    required this.chargingStatus,
+    this.location,
+    required this.lastUpdated,
+  });
+  
+  factory VehicleStatus.fromJson(Map<String, dynamic> json) {
+    return VehicleStatus(
+      vehicleId: json['vehicle_id'],
+      lockStatus: LockStatus.fromString(json['lock_status']),
+      batteryStatus: BatteryStatus.fromJson(json['battery_status']),
+      climatisationStatus: ClimatisationStatus.fromJson(json['climatisation_status']),
+      chargingStatus: ChargingStatus.fromJson(json['charging_status']),
+      location: json['location'] != null 
+          ? VehicleLocation.fromJson(json['location']) 
+          : null,
+      lastUpdated: DateTime.parse(json['last_updated']),
+    );
+  }
+}
+```
+
+### 车辆控制命令模型
+```dart
+// 车辆控制命令
+abstract class VehicleCommand {
+  const VehicleCommand();
+  
+  // 车门锁命令
+  factory VehicleCommand.lock() = LockCommand;
+  factory VehicleCommand.unlock() = UnlockCommand;
+  
+  // 空调命令
+  factory VehicleCommand.startClimatisation({
+    required double temperature,
+    AirConditioningMode mode,
+  }) = StartClimatisationCommand;
+  
+  factory VehicleCommand.stopClimatisation() = StopClimatisationCommand;
+  
+  // 充电命令
+  factory VehicleCommand.startCharging({
+    ChargingProfile? profile,
+  }) = StartChargingCommand;
+  
+  factory VehicleCommand.stopCharging() = StopChargingCommand;
+  
+  // 车辆查找命令
+  factory VehicleCommand.flashAndHonk() = FlashAndHonkCommand;
+}
+```
+
+## 枚举定义 (`car_enum/`)
+
+### 车辆状态枚举
+```dart
+// 车门锁状态
+enum LockStatus {
+  locked,
+  unlocked,
+  unknown;
+  
+  static LockStatus fromString(String value) {
+    switch (value.toLowerCase()) {
+      case 'locked':
+        return LockStatus.locked;
+      case 'unlocked':
+        return LockStatus.unlocked;
+      default:
+        return LockStatus.unknown;
+    }
+  }
+}
+
+// 充电状态
+enum ChargingStatus {
+  notConnected,
+  connected,
+  charging,
+  chargingComplete,
+  chargingError;
+  
+  bool get isCharging => this == ChargingStatus.charging;
+  bool get isConnected => this != ChargingStatus.notConnected;
+}
+
+// 空调模式
+enum AirConditioningMode {
+  auto,
+  heat,
+  cool,
+  ventilation,
+  defrost;
+  
+  String get displayName {
+    switch (this) {
+      case AirConditioningMode.auto:
+        return '自动';
+      case AirConditioningMode.heat:
+        return '制热';
+      case AirConditioningMode.cool:
+        return '制冷';
+      case AirConditioningMode.ventilation:
+        return '通风';
+      case AirConditioningMode.defrost:
+        return '除霜';
+    }
+  }
+}
+```
+
+## UI 组件 (`car_common_widget/`)
+
+### 车辆状态卡片
+```dart
+// 车辆状态卡片组件
+class VehicleStatusCard extends StatelessWidget {
+  final VehicleStatus status;
+  final VoidCallback? onRefresh;
+  
+  const VehicleStatusCard({
+    Key? key,
+    required this.status,
+    this.onRefresh,
+  }) : super(key: key);
+  
+  @override
+  Widget build(BuildContext context) {
+    return Card(
+      child: Padding(
+        padding: EdgeInsets.all(16),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            _buildHeader(),
+            SizedBox(height: 16),
+            _buildStatusGrid(),
+            SizedBox(height: 16),
+            _buildActionButtons(),
+          ],
+        ),
+      ),
+    );
+  }
+  
+  Widget _buildStatusGrid() {
+    return GridView.count(
+      shrinkWrap: true,
+      physics: NeverScrollableScrollPhysics(),
+      crossAxisCount: 2,
+      children: [
+        _buildStatusItem('车门', status.lockStatus.displayName),
+        _buildStatusItem('电量', '${status.batteryStatus.percentage}%'),
+        _buildStatusItem('空调', status.climatisationStatus.displayName),
+        _buildStatusItem('充电', status.chargingStatus.displayName),
+      ],
+    );
+  }
+}
+```
+
+### 车辆控制面板
+```dart
+// 车辆控制面板
+class VehicleControlPanel extends StatelessWidget {
+  final VehicleStatus status;
+  final Function(VehicleCommand) onCommand;
+  
+  const VehicleControlPanel({
+    Key? key,
+    required this.status,
+    required this.onCommand,
+  }) : super(key: key);
+  
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      children: [
+        _buildLockControls(),
+        SizedBox(height: 16),
+        _buildClimatisationControls(),
+        SizedBox(height: 16),
+        _buildChargingControls(),
+        SizedBox(height: 16),
+        _buildFinderControls(),
+      ],
+    );
+  }
+  
+  Widget _buildLockControls() {
+    return Row(
+      children: [
+        Expanded(
+          child: ElevatedButton.icon(
+            onPressed: status.lockStatus == LockStatus.unlocked
+                ? () => onCommand(VehicleCommand.lock())
+                : null,
+            icon: Icon(Icons.lock),
+            label: Text('上锁'),
+          ),
+        ),
+        SizedBox(width: 8),
+        Expanded(
+          child: ElevatedButton.icon(
+            onPressed: status.lockStatus == LockStatus.locked
+                ? () => onCommand(VehicleCommand.unlock())
+                : null,
+            icon: Icon(Icons.lock_open),
+            label: Text('解锁'),
+          ),
+        ),
+      ],
+    );
+  }
+}
+```
+
+## 动画效果 (`car_animation/`)
+
+### 车辆控制动画
+```dart
+// 车辆控制动画控制器
+class VehicleAnimationController extends ChangeNotifier {
+  late AnimationController _lockAnimationController;
+  late AnimationController _chargingAnimationController;
+  
+  Animation<double> get lockAnimation => _lockAnimationController;
+  Animation<double> get chargingAnimation => _chargingAnimationController;
+  
+  void initialize(TickerProvider vsync) {
+    _lockAnimationController = AnimationController(
+      duration: Duration(milliseconds: 500),
+      vsync: vsync,
+    );
+    
+    _chargingAnimationController = AnimationController(
+      duration: Duration(milliseconds: 1500),
+      vsync: vsync,
+    )..repeat();
+  }
+  
+  void playLockAnimation() {
+    _lockAnimationController.forward().then((_) {
+      _lockAnimationController.reverse();
+    });
+  }
+  
+  void startChargingAnimation() {
+    _chargingAnimationController.repeat();
+  }
+  
+  void stopChargingAnimation() {
+    _chargingAnimationController.stop();
+  }
+}
+```
+
+## AI 聊天集成 (`ai_chat/`)
+
+### AI 聊天车辆控制
+```dart
+// AI 聊天车辆控制集成
+class AIChatVehicleIntegration {
+  final VehicleControlRepository _vehicleRepository;
+  final AIChatAssistant _aiAssistant;
+  
+  AIChatVehicleIntegration(this._vehicleRepository, this._aiAssistant);
+  
+  // 处理车辆控制语音命令
+  Future<AIChatResponse> handleVehicleCommand(String command) async {
+    final intent = await _aiAssistant.parseIntent(command);
+    
+    switch (intent.type) {
+      case VehicleIntentType.lock:
+        return await _handleLockCommand();
+      case VehicleIntentType.unlock:
+        return await _handleUnlockCommand();
+      case VehicleIntentType.startAC:
+        return await _handleStartACCommand(intent.parameters);
+      case VehicleIntentType.stopAC:
+        return await _handleStopACCommand();
+      default:
+        return AIChatResponse.error('未识别的车辆控制命令');
+    }
+  }
+  
+  Future<AIChatResponse> _handleLockCommand() async {
+    final result = await _vehicleRepository.lockVehicle();
+    return result.fold(
+      (failure) => AIChatResponse.error('车辆上锁失败：${failure.message}'),
+      (_) => AIChatResponse.success('车辆已成功上锁'),
+    );
+  }
+}
+```
+
+## 依赖管理
+
+基于实际的pubspec.yaml配置，展示真实的项目依赖关系。
+
+### 核心依赖
+```yaml
+# 车辆连接和服务依赖
+dependencies:
+  car_connector: ^0.4.11        # 车联网连接服务
+  car_vehicle: ^0.6.4+1         # 车辆基础服务
+  car_vur: ^0.1.12              # 车辆更新记录
+  flutter_ingeek_carkey: 1.6.2  # 数字钥匙 SDK
+  
+  # 框架依赖
+  basic_modular: ^0.2.3         # 模块化框架
+  basic_modular_route: ^0.2.1   # 路由管理
+  basic_intl: ^0.2.0            # 国际化支持
+  basic_storage: ^0.2.2         # 本地存储
+  
+  # 业务服务依赖
+  clr_mno: ^0.2.2               # MNO 服务
+  clr_geo: ^0.2.16+1            # 地理位置服务
+  
+  # 功能性依赖
+  dartz: ^0.10.1                # 函数式编程支持
+  freezed_annotation: ^2.2.0    # 不可变类生成
+  json_annotation: ^4.9.0       # JSON 序列化
+  
+  # AI功能集成
+  ai_chat_assistant:            # AI 聊天助手模块
+    path: ../ai_chat_assistant
+    
+  # UI组件依赖
+  carousel_slider: ^4.2.1       # 轮播图组件
+  flutter_slidable: ^3.1.2     # 滑动组件
+  overlay_support: ^2.1.0       # 覆盖层支持
+  provider: ^6.0.5              # 状态管理
+```
+
+### 模块间依赖关系
+```dart
+// 实际的模块依赖结构（基于项目配置）
+app_car/
+├── car_connector: 车辆连接服务 (核心通信)
+├── car_vehicle: 车辆基础服务 (状态管理)  
+├── car_vur: 车辆更新记录 (版本控制)
+├── flutter_ingeek_carkey: 数字钥匙SDK (安全认证)
+├── ai_chat_assistant: AI聊天助手 (智能交互)
+├── clr_mno: MNO服务 (网络运营商)
+├── clr_geo: 地理位置服务 (定位功能)
+└── basic_*: 基础框架模块群
+```
+
+## 路由配置 (`route_dp.dart`, `route_export.dart`)
+
+### 路由定义
+```dart
+// 车辆模块路由配置
+class CarRoutes {
+  static const String vehicleStatus = '/car/status';
+  static const String vehicleControl = '/car/control';
+  static const String chargingCenter = '/car/charging';
+  static const String digitalKey = '/car/digital-key';
+  static const String carFinder = '/car/finder';
+  static const String climatisation = '/car/climatisation';
+  
+  static List<ModularRoute> get routes => [
+    ChildRoute(
+      vehicleStatus,
+      child: (context, args) => VehicleStatusPage(),
+    ),
+    ChildRoute(
+      vehicleControl,
+      child: (context, args) => VehicleControlPage(),
+    ),
+    ChildRoute(
+      chargingCenter,
+      child: (context, args) => ChargingCenterPage(),
+    ),
+    ChildRoute(
+      digitalKey,
+      child: (context, args) => DigitalKeyPage(),
+    ),
+    ChildRoute(
+      carFinder,
+      child: (context, args) => CarFinderPage(),
+    ),
+    ChildRoute(
+      climatisation,
+      child: (context, args) => ClimatisationPage(),
+    ),
+  ];
+}
+```
+
+## 常量定义 (`constants/`)
+
+### 车辆常量
+```dart
+// 车辆控制常量
+class CarConstants {
+  // 温度范围
+  static const double minTemperature = 16.0;
+  static const double maxTemperature = 32.0;
+  static const double defaultTemperature = 22.0;
+  
+  // 充电相关
+  static const int minChargingTarget = 20;
+  static const int maxChargingTarget = 100;
+  static const int defaultChargingTarget = 80;
+  
+  // 动画时长
+  static const Duration lockAnimationDuration = Duration(milliseconds: 500);
+  static const Duration statusUpdateInterval = Duration(seconds: 30);
+  
+  // 错误重试
+  static const int maxRetryCount = 3;
+  static const Duration retryDelay = Duration(seconds: 2);
+}
+```
+
+## 错误处理
+
+### 车辆特定异常
+```dart
+// 车辆操作异常
+abstract class VehicleFailure {
+  const VehicleFailure();
+  
+  factory VehicleFailure.networkError(String message) = NetworkFailure;
+  factory VehicleFailure.authenticationError() = AuthenticationFailure;
+  factory VehicleFailure.vehicleNotFound() = VehicleNotFoundFailure;
+  factory VehicleFailure.commandTimeout() = CommandTimeoutFailure;
+  factory VehicleFailure.vehicleOffline() = VehicleOfflineFailure;
+  factory VehicleFailure.insufficientBattery() = InsufficientBatteryFailure;
+}
+
+class NetworkFailure extends VehicleFailure {
+  final String message;
+  const NetworkFailure(this.message);
+}
+
+class VehicleOfflineFailure extends VehicleFailure {
+  const VehicleOfflineFailure();
+}
+```
+
+## 性能优化
+
+### 状态缓存策略
+- 车辆状态本地缓存
+- 智能刷新机制
+- 后台状态同步
+
+### 网络优化
+- 命令队列管理
+- 批量请求处理
+- 离线命令缓存
+
+### UI 优化
+- 状态变更动画
+- 加载状态指示
+- 错误状态处理
+
+## 测试策略
+
+### 单元测试
+- BLoC 状态管理测试
+- 服务类功能测试
+- 模型序列化测试
+
+### 集成测试
+- 车联网通信测试
+- 状态同步测试
+- 命令执行测试
+
+### UI 测试
+- 控制面板交互测试
+- 状态显示测试
+- 错误场景测试
+
+## 总结
+
+`app_car` 模块是 OneApp 车辆功能的核心，提供了完整的车辆控制和状态管理功能。模块采用 BLoC 模式进行状态管理，具有清晰的分层架构和良好的可扩展性。通过集成 AI 聊天助手和数字钥匙技术，为用户提供了智能化和便捷的车辆操作体验。