如果您有任何疑问、对文章写的不满意、发现错误或者有更好的方法，欢迎在评论、私信或邮件中提出，非常感谢您的支持。🙏
嘻嘻嘻，关注我！！！黑马波哥

一、整体架构设计

1.1 系统架构图

1.2 技术栈选型

# pubspec.yaml 关键依赖
dependencies:
  flutter:
    sdk: flutter
  
  # 状态管理
  flutter_bloc: ^8.1.2
  equatable: ^2.0.5
  
  # 表单处理
  flutter_form_builder: ^8.0.1
  formz: ^0.5.1
  
  # 地图服务
  flutter_map: ^5.0.0
  mapbox_gl: ^0.18.0
  
  # 图片处理
  image_picker: ^0.8.7+4
  cached_network_image: ^3.2.3
  image_cropper: ^3.0.1
  
  # HarmonyOS集成
  harmony_flutter_bridge: ^1.0.0
  harmony_permissions: ^1.0.0
  harmony_location: ^1.0.0
  
  # 工具类
  intl: ^0.18.1
  dio: ^5.0.0
  shared_preferences: ^2.1.0

二、编辑页面核心实现

2.1 房屋编辑页面架构

/// 文件路径：lib/ui/house_edit/house_edit_page.dart
/// 
/// 房屋编辑主页面
/// 符合鸿蒙设计规范的多步骤表单

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_form_builder/flutter_form_builder.dart';

class HouseEditPage extends StatefulWidget {
  final String? houseId; // 新建时为null，编辑时传入ID
  
  const HouseEditPage({Key? key, this.houseId}) : super(key: key);
  
  @override
  _HouseEditPageState createState() => _HouseEditPageState();
}

class _HouseEditPageState extends State<HouseEditPage> 
    with SingleTickerProviderStateMixin {
  
  late TabController _tabController;
  final GlobalKey<FormBuilderState> _formKey = GlobalKey<FormBuilderState>();
  final List<String> _tabTitles = [
    '基本信息',
    '房源详情',
    '配套设施',
    '图片管理',
    '位置信息',
    '价格设置'
  ];
  
  @override
  void initState() {
    super.initState();
    _tabController = TabController(
      length: _tabTitles.length,
      vsync: this,
    );
    
    // 加载房屋数据
    if (widget.houseId != null) {
      context.read<HouseEditBloc>().add(
        HouseEditLoadRequested(widget.houseId!)
      );
    }
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      // 鸿蒙风格的应用栏
      appBar: _buildHarmonyAppBar(),
      body: _buildBody(),
      // 鸿蒙风格的底部操作栏
      bottomNavigationBar: _buildBottomBar(),
    );
  }
  
  /// 构建鸿蒙风格的应用栏
  AppBar _buildHarmonyAppBar() {
    return AppBar(
      title: Text(
        widget.houseId == null ? '新增房源' : '编辑房源',
        style: TextStyle(
          fontSize: 20,
          fontWeight: FontWeight.w600,
          color: Theme.of(context).colorScheme.onSurface,
        ),
      ),
      centerTitle: true,
      elevation: 0,
      backgroundColor: Theme.of(context).colorScheme.surface,
      // 鸿蒙风格的TabBar
      bottom: PreferredSize(
        preferredSize: const Size.fromHeight(48),
        child: Container(
          decoration: BoxDecoration(
            color: Theme.of(context).colorScheme.surface,
            border: Border(
              bottom: BorderSide(
                color: Theme.of(context).dividerColor,
                width: 0.5,
              ),
            ),
          ),
          child: TabBar(
            controller: _tabController,
            isScrollable: true,
            labelColor: Theme.of(context).colorScheme.primary,
            unselectedLabelColor: Theme.of(context).colorScheme.onSurfaceVariant,
            indicatorColor: Theme.of(context).colorScheme.primary,
            tabs: _tabTitles.map((title) => Tab(text: title)).toList(),
          ),
        ),
      ),
    );
  }
  
  /// 构建页面主体
  Widget _buildBody() {
    return BlocConsumer<HouseEditBloc, HouseEditState>(
      listener: (context, state) {
        if (state.status == HouseEditStatus.saveSuccess) {
          _showSuccessSnackBar();
          Navigator.of(context).pop(true);
        } else if (state.status == HouseEditStatus.saveFailure) {
          _showErrorSnackBar(state.errorMessage ?? '保存失败');
        }
      },
      builder: (context, state) {
        if (state.status == HouseEditStatus.loading) {
          return const Center(child: CircularProgressIndicator());
        }
        
        return FormBuilder(
          key: _formKey,
          child: TabBarView(
            controller: _tabController,
            children: [
              BasicInfoTab(formData: state.formData),
              DetailInfoTab(formData: state.formData),
              FacilitiesTab(formData: state.formData),
              ImageManagerTab(images: state.images),
              LocationTab(formData: state.formData),
              PriceSettingTab(formData: state.formData),
            ],
          ),
        );
      },
    );
  }
  
  /// 构建鸿蒙风格的底部操作栏
  Widget _buildBottomBar() {
    return BlocBuilder<HouseEditBloc, HouseEditState>(
      builder: (context, state) {
        return Container(
          decoration: BoxDecoration(
            color: Theme.of(context).colorScheme.surface,
            border: Border(
              top: BorderSide(
                color: Theme.of(context).dividerColor,
                width: 0.5,
              ),
            ),
          ),
          padding: const EdgeInsets.symmetric(
            horizontal: 16,
            vertical: 12,
          ),
          child: Row(
            children: [
              // 预览按钮
              Expanded(
                child: OutlinedButton(
                  onPressed: () => _previewHouse(),
                  child: const Text('预览'),
                ),
              ),
              const SizedBox(width: 12),
              // 保存按钮
              Expanded(
                child: ElevatedButton(
                  onPressed: state.status == HouseEditStatus.saving
                      ? null
                      : () => _saveHouse(),
                  style: ElevatedButton.styleFrom(
                    backgroundColor: Theme.of(context).colorScheme.primary,
                    foregroundColor: Theme.of(context).colorScheme.onPrimary,
                  ),
                  child: state.status == HouseEditStatus.saving
                      ? const SizedBox(
                          width: 20,
                          height: 20,
                          child: CircularProgressIndicator(
                            strokeWidth: 2,
                            valueColor: AlwaysStoppedAnimation(Colors.white),
                          ),
                        )
                      : const Text('保存房源'),
                ),
              ),
            ],
          ),
        );
      },
    );
  }
  
  /// 保存房屋信息
  void _saveHouse() {
    if (_formKey.currentState?.saveAndValidate() ?? false) {
      final formData = _formKey.currentState!.value;
      
      // 触发保存事件
      context.read<HouseEditBloc>().add(
        HouseEditSaveRequested(
          houseId: widget.houseId,
          formData: formData,
        ),
      );
    }
  }
  
  /// 预览房屋信息
  void _previewHouse() {
    if (_formKey.currentState?.saveAndValidate() ?? false) {
      final formData = _formKey.currentState!.value;
      
      Navigator.of(context).push(
        MaterialPageRoute(
          builder: (context) => HousePreviewPage(formData: formData),
        ),
      );
    }
  }
  
  void _showSuccessSnackBar() {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Text(
          '房源保存成功',
          style: TextStyle(color: Theme.of(context).colorScheme.onPrimary),
        ),
        backgroundColor: Theme.of(context).colorScheme.primary,
        behavior: SnackBarBehavior.floating,
        shape: RoundedRectangleBorder(
          borderRadius: BorderRadius.circular(8),
        ),
      ),
    );
  }
  
  void _showErrorSnackBar(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Text(message),
        backgroundColor: Theme.of(context).colorScheme.error,
      ),
    );
  }
}

2.2 基本信息Tab组件

/// 文件路径：lib/ui/house_edit/tabs/basic_info_tab.dart
/// 
/// 基本信息表单组件
/// 包含房源标题、类型、面积等基本信息

import 'package:flutter/material.dart';
import 'package:flutter_form_builder/flutter_form_builder.dart';
import 'package:form_builder_validators/form_builder_validators.dart';

class BasicInfoTab extends StatelessWidget {
  final Map<String, dynamic>? formData;
  
  const BasicInfoTab({Key? key, this.formData}) : super(key: key);
  
  @override
  Widget build(BuildContext context) {
    return SingleChildScrollView(
      padding: const EdgeInsets.all(16),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          // 房源标题
          _buildTitleField(),
          const SizedBox(height: 20),
          
          // 房源类型选择
          _buildTypeSelection(),
          const SizedBox(height: 20),
          
          // 面积信息
          _buildAreaFields(),
          const SizedBox(height: 20),
          
          // 户型信息
          _buildLayoutFields(),
          const SizedBox(height: 20),
          
          // 朝向选择
          _buildOrientationField(),
        ],
      ),
    );
  }
  
  /// 房源标题输入框
  Widget _buildTitleField() {
    return FormBuilderTextField(
      name: 'title',
      initialValue: formData?['title'] ?? '',
      decoration: InputDecoration(
        labelText: '房源标题',
        hintText: '请输入房源标题（如：阳光小区两室一厅）',
        border: OutlineInputBorder(
          borderRadius: BorderRadius.circular(8),
        ),
        prefixIcon: const Icon(Icons.title),
        filled: true,
        fillColor: Colors.grey[50],
      ),
      validator: FormBuilderValidators.compose([
        FormBuilderValidators.required(errorText: '请输入房源标题'),
        FormBuilderValidators.maxLength(50, errorText: '标题不能超过50个字'),
      ]),
      maxLines: 1,
      textInputAction: TextInputAction.next,
    );
  }
  
  /// 房源类型选择
  Widget _buildTypeSelection() {
    final houseTypes = [
      {'value': 'apartment', 'label': '公寓', 'icon': Icons.apartment},
      {'value': 'villa', 'label': '别墅', 'icon': Icons.villa},
      {'value': 'townhouse', 'label': '联排别墅', 'icon': Icons.home_work},
      {'value': 'commercial', 'label': '商铺', 'icon': Icons.store},
      {'value': 'office', 'label': '写字楼', 'icon': Icons.business},
    ];
    
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Text(
          '房源类型',
          style: TextStyle(
            fontSize: 14,
            fontWeight: FontWeight.w500,
            color: Colors.grey[700],
          ),
        ),
        const SizedBox(height: 8),
        Wrap(
          spacing: 8,
          runSpacing: 8,
          children: houseTypes.map((type) {
            return ChoiceChip(
              label: Row(
                mainAxisSize: MainAxisSize.min,
                children: [
                  Icon(type['icon'] as IconData, size: 16),
                  const SizedBox(width: 4),
                  Text(type['label'] as String),
                ],
              ),
              selected: formData?['type'] == type['value'],
              onSelected: (selected) {
                // 通过FormBuilder管理选择状态
              },
              selectedColor: Theme.of(context).colorScheme.primary,
              labelStyle: TextStyle(
                color: formData?['type'] == type['value'] 
                    ? Colors.white 
                    : Colors.black,
              ),
            );
          }).toList(),
        ),
        FormBuilderField(
          name: 'type',
          initialValue: formData?['type'] ?? 'apartment',
          builder: (FormFieldState<dynamic> field) {
            return const SizedBox.shrink();
          },
        ),
      ],
    );
  }
  
  /// 面积输入字段
  Widget _buildAreaFields() {
    return Row(
      children: [
        Expanded(
          child: FormBuilderTextField(
            name: 'area',
            initialValue: formData?['area']?.toString() ?? '',
            decoration: InputDecoration(
              labelText: '建筑面积',
              hintText: '请输入',
              border: OutlineInputBorder(
                borderRadius: BorderRadius.circular(8),
              ),
              suffixText: '㎡',
              filled: true,
              fillColor: Colors.grey[50],
            ),
            keyboardType: TextInputType.number,
            validator: FormBuilderValidators.compose([
              FormBuilderValidators.required(errorText: '请输入建筑面积'),
              FormBuilderValidators.numeric(errorText: '请输入数字'),
              FormBuilderValidators.min(1, errorText: '面积必须大于0'),
            ]),
          ),
        ),
        const SizedBox(width: 16),
        Expanded(
          child: FormBuilderTextField(
            name: 'usable_area',
            initialValue: formData?['usable_area']?.toString() ?? '',
            decoration: InputDecoration(
              labelText: '使用面积',
              hintText: '请输入',
              border: OutlineInputBorder(
                borderRadius: BorderRadius.circular(8),
              ),
              suffixText: '㎡',
              filled: true,
              fillColor: Colors.grey[50],
            ),
            keyboardType: TextInputType.number,
            validator: FormBuilderValidators.compose([
              FormBuilderValidators.numeric(errorText: '请输入数字'),
            ]),
          ),
        ),
      ],
    );
  }
  
  /// 户型信息
  Widget _buildLayoutFields() {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Text(
          '户型信息',
          style: TextStyle(
            fontSize: 14,
            fontWeight: FontWeight.w500,
            color: Colors.grey[700],
          ),
        ),
        const SizedBox(height: 12),
        Row(
          children: [
            _buildRoomField('bedrooms', '室', Icons.bed),
            const SizedBox(width: 16),
            _buildRoomField('living_rooms', '厅', Icons.living),
            const SizedBox(width: 16),
            _buildRoomField('bathrooms', '卫', Icons.bathtub),
            const SizedBox(width: 16),
            _buildRoomField('balconies', '阳台', Icons.balcony),
          ],
        ),
      ],
    );
  }
  
  Widget _buildRoomField(String name, String suffix, IconData icon) {
    return Expanded(
      child: FormBuilderTextField(
        name: name,
        initialValue: formData?[name]?.toString() ?? '0',
        decoration: InputDecoration(
          labelText: suffix,
          border: OutlineInputBorder(
            borderRadius: BorderRadius.circular(8),
          ),
          prefixIcon: Icon(icon, size: 20),
          filled: true,
          fillColor: Colors.grey[50],
        ),
        keyboardType: TextInputType.number,
        validator: FormBuilderValidators.compose([
          FormBuilderValidators.numeric(errorText: '请输入数字'),
          FormBuilderValidators.min(0, errorText: '不能小于0'),
        ]),
      ),
    );
  }
  
  /// 朝向选择
  Widget _buildOrientationField() {
    final orientations = ['东', '南', '西', '北', '东南', '西南', '东北', '西北'];
    
    return FormBuilderFilterChip(
      name: 'orientations',
      initialValue: formData?['orientations'] ?? [],
      decoration: InputDecoration(
        labelText: '房屋朝向',
        border: InputBorder.none,
        alignLabelWithHint: true,
      ),
      options: orientations
          .map((orientation) => FormBuilderFieldOption(
                value: orientation,
                child: Text(orientation),
              ))
          .toList(),
      selectedColor: Theme.of(context).colorScheme.primary,
      checkmarkColor: Colors.white,
      validator: FormBuilderValidators.compose([
        FormBuilderValidators.minLength(1, errorText: '请至少选择一个朝向'),
      ]),
    );
  }
}

三、状态管理（BLoC模式）

3.1 编辑状态管理

/// 文件路径：lib/bloc/house_edit/house_edit_bloc.dart
/// 
/// 房屋编辑业务逻辑控制器
/// 管理编辑状态、表单数据和保存操作

import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';
import 'package:xiangjia_community/models/house_model.dart';
import 'package:xiangjia_community/repositories/house_repository.dart';

/// 编辑状态枚举
enum HouseEditStatus {
  initial,
  loading,
  loaded,
  saving,
  saveSuccess,
  saveFailure,
  imageUploading,
  imageUploadSuccess,
  imageUploadFailure,
}

/// 编辑事件基类
abstract class HouseEditEvent extends Equatable {
  const HouseEditEvent();
  
  @override
  List<Object?> get props => [];
}

/// 加载房屋数据事件
class HouseEditLoadRequested extends HouseEditEvent {
  final String houseId;
  
  const HouseEditLoadRequested(this.houseId);
  
  @override
  List<Object?> get props => [houseId];
}

/// 保存房屋数据事件
class HouseEditSaveRequested extends HouseEditEvent {
  final String? houseId;
  final Map<String, dynamic> formData;
  
  const HouseEditSaveRequested({
    this.houseId,
    required this.formData,
  });
  
  @override
  List<Object?> get props => [houseId, formData];
}

/// 上传图片事件
class HouseEditImageUploadRequested extends HouseEditEvent {
  final List<XFile> imageFiles;
  final bool isCover;
  
  const HouseEditImageUploadRequested({
    required this.imageFiles,
    this.isCover = false,
  });
  
  @override
  List<Object?> get props => [imageFiles, isCover];
}

/// 删除图片事件
class HouseEditImageDeleteRequested extends HouseEditEvent {
  final String imageId;
  
  const HouseEditImageDeleteRequested(this.imageId);
  
  @override
  List<Object?> get props => [imageId];
}

/// 房屋编辑状态类
class HouseEditState extends Equatable {
  final HouseEditStatus status;
  final House? house;
  final Map<String, dynamic> formData;
  final List<HouseImage> images;
  final String? errorMessage;
  final double uploadProgress;
  
  const HouseEditState({
    this.status = HouseEditStatus.initial,
    this.house,
    this.formData = const {},
    this.images = const [],
    this.errorMessage,
    this.uploadProgress = 0.0,
  });
  
  /// 复制状态方法
  HouseEditState copyWith({
    HouseEditStatus? status,
    House? house,
    Map<String, dynamic>? formData,
    List<HouseImage>? images,
    String? errorMessage,
    double? uploadProgress,
  }) {
    return HouseEditState(
      status: status ?? this.status,
      house: house ?? this.house,
      formData: formData ?? this.formData,
      images: images ?? this.images,
      errorMessage: errorMessage ?? this.errorMessage,
      uploadProgress: uploadProgress ?? this.uploadProgress,
    );
  }
  
  @override
  List<Object?> get props => [
    status,
    house,
    formData,
    images,
    errorMessage,
    uploadProgress,
  ];
}

/// 房屋编辑BLoC控制器
class HouseEditBloc extends Bloc<HouseEditEvent, HouseEditState> {
  final HouseRepository houseRepository;
  final ImagePicker imagePicker;
  
  HouseEditBloc({
    required this.houseRepository,
    required this.imagePicker,
  }) : super(const HouseEditState()) {
    
    // 注册事件处理器
    on<HouseEditLoadRequested>(_onLoadRequested);
    on<HouseEditSaveRequested>(_onSaveRequested);
    on<HouseEditImageUploadRequested>(_onImageUploadRequested);
    on<HouseEditImageDeleteRequested>(_onImageDeleteRequested);
  }
  
  /// 处理加载请求
  Future<void> _onLoadRequested(
    HouseEditLoadRequested event,
    Emitter<HouseEditState> emit,
  ) async {
    try {
      emit(state.copyWith(status: HouseEditStatus.loading));
      
      // 从仓库加载房屋数据
      final house = await houseRepository.getHouse(event.houseId);
      final images = await houseRepository.getHouseImages(event.houseId);
      
      // 将房屋数据转换为表单数据
      final formData = _convertHouseToFormData(house);
      
      emit(state.copyWith(
        status: HouseEditStatus.loaded,
        house: house,
        formData: formData,
        images: images,
      ));
      
    } catch (error) {
      emit(state.copyWith(
        status: HouseEditStatus.saveFailure,
        errorMessage: '加载失败: ${error.toString()}',
      ));
    }
  }
  
  /// 处理保存请求
  Future<void> _onSaveRequested(
    HouseEditSaveRequested event,
    Emitter<HouseEditState> emit,
  ) async {
    try {
      emit(state.copyWith(status: HouseEditStatus.saving));
      
      final houseData = _convertFormDataToHouse(event.formData);
      
      if (event.houseId == null) {
        // 创建新房屋
        final newHouse = await houseRepository.createHouse(houseData);
        emit(state.copyWith(
          status: HouseEditStatus.saveSuccess,
          house: newHouse,
        ));
      } else {
        // 更新现有房屋
        final updatedHouse = await houseRepository.updateHouse(
          event.houseId!,
          houseData,
        );
        emit(state.copyWith(
          status: HouseEditStatus.saveSuccess,
          house: updatedHouse,
        ));
      }
      
    } catch (error) {
      emit(state.copyWith(
        status: HouseEditStatus.saveFailure,
        errorMessage: '保存失败: ${error.toString()}',
      ));
    }
  }
  
  /// 处理图片上传
  Future<void> _onImageUploadRequested(
    HouseEditImageUploadRequested event,
    Emitter<HouseEditState> emit,
  ) async {
    try {
      emit(state.copyWith(
        status: HouseEditStatus.imageUploading,
        uploadProgress: 0.1,
      ));
      
      // 上传图片
      final uploadedImages = await houseRepository.uploadHouseImages(
        state.house?.id ?? 'temp',
        event.imageFiles,
        onProgress: (progress) {
          emit(state.copyWith(uploadProgress: progress));
        },
        isCover: event.isCover,
      );
      
      // 更新图片列表
      final updatedImages = List<HouseImage>.from(state.images)
        ..addAll(uploadedImages);
      
      emit(state.copyWith(
        status: HouseEditStatus.imageUploadSuccess,
        images: updatedImages,
        uploadProgress: 1.0,
      ));
      
    } catch (error) {
      emit(state.copyWith(
        status: HouseEditStatus.imageUploadFailure,
        errorMessage: '图片上传失败: ${error.toString()}',
        uploadProgress: 0.0,
      ));
    }
  }
  
  /// 将房屋数据转换为表单数据
  Map<String, dynamic> _convertHouseToFormData(House house) {
    return {
      'title': house.title,
      'type': house.type,
      'area': house.area,
      'usable_area': house.usableArea,
      'bedrooms': house.bedrooms,
      'living_rooms': house.livingRooms,
      'bathrooms': house.bathrooms,
      'balconies': house.balconies,
      'orientations': house.orientations,
      'description': house.description,
      'price': house.price,
      'price_unit': house.priceUnit,
      // ... 其他字段
    };
  }
  
  /// 将表单数据转换为房屋数据
  Map<String, dynamic> _convertFormDataToHouse(Map<String, dynamic> formData) {
    return {
      'title': formData['title'],
      'type': formData['type'],
      'area': double.parse(formData['area'].toString()),
      'usable_area': double.parse(formData['usable_area']?.toString() ?? '0'),
      'bedrooms': int.parse(formData['bedrooms']?.toString() ?? '0'),
      'living_rooms': int.parse(formData['living_rooms']?.toString() ?? '0'),
      'bathrooms': int.parse(formData['bathrooms']?.toString() ?? '0'),
      'balconies': int.parse(formData['balconies']?.toString() ?? '0'),
      'orientations': formData['orientations'] as List<String>,
      'description': formData['description'],
      'price': double.parse(formData['price']?.toString() ?? '0'),
      'price_unit': formData['price_unit'],
      // ... 其他字段
    };
  }
}

四、图片管理功能

4.1 图片管理组件

/// 文件路径：lib/ui/house_edit/tabs/image_manager_tab.dart
/// 
/// 图片管理组件
/// 支持拍照、从相册选择、图片排序和删除

import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:image_picker/image_picker.dart';

class ImageManagerTab extends StatelessWidget {
  final List<HouseImage> images;
  
  const ImageManagerTab({Key? key, required this.images}) : super(key: key);
  
  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        // 操作按钮栏
        _buildActionBar(context),
        // 图片网格展示
        Expanded(
          child: _buildImageGrid(context),
        ),
      ],
    );
  }
  
  /// 构建操作按钮栏
  Widget _buildActionBar(BuildContext context) {
    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        border: Border(
          bottom: BorderSide(
            color: Theme.of(context).dividerColor,
            width: 0.5,
          ),
        ),
      ),
      child: Row(
        children: [
          // 添加图片按钮
          Expanded(
            child: OutlinedButton.icon(
              onPressed: () => _showImageSourceDialog(context),
              icon: const Icon(Icons.add_photo_alternate),
              label: const Text('添加图片'),
              style: OutlinedButton.styleFrom(
                padding: const EdgeInsets.symmetric(vertical: 12),
              ),
            ),
          ),
          const SizedBox(width: 12),
          // 设置封面按钮
          if (images.isNotEmpty)
            Expanded(
              child: OutlinedButton.icon(
                onPressed: () => _setCoverImage(context),
                icon: const Icon(Icons.star_border),
                label: const Text('设置封面'),
                style: OutlinedButton.styleFrom(
                  padding: const EdgeInsets.symmetric(vertical: 12),
                ),
              ),
            ),
        ],
      ),
    );
  }
  
  /// 构建图片网格
  Widget _buildImageGrid(BuildContext context) {
    return GridView.builder(
      padding: const EdgeInsets.all(16),
      gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
        crossAxisCount: 3,
        crossAxisSpacing: 8,
        mainAxisSpacing: 8,
        childAspectRatio: 1,
      ),
      itemCount: images.length + 1, // +1 为添加按钮
      itemBuilder: (context, index) {
        if (index == 0) {
          return _buildAddImageButton(context);
        } else {
          final imageIndex = index - 1;
          return _buildImageItem(context, images[imageIndex], imageIndex);
        }
      },
    );
  }
  
  /// 构建添加图片按钮
  Widget _buildAddImageButton(BuildContext context) {
    return GestureDetector(
      onTap: () => _showImageSourceDialog(context),
      child: Container(
        decoration: BoxDecoration(
          color: Colors.grey[100],
          borderRadius: BorderRadius.circular(8),
          border: Border.all(
            color: Colors.grey[300],
            width: 1,
          ),
        ),
        child: const Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Icon(Icons.add_a_photo, size: 32, color: Colors.grey),
            SizedBox(height: 8),
            Text(
              '添加图片',
              style: TextStyle(
                fontSize: 12,
                color: Colors.grey,
              ),
            ),
          ],
        ),
      ),
    );
  }
  
  /// 构建图片项
  Widget _buildImageItem(BuildContext context, HouseImage image, int index) {
    return Stack(
      children: [
        // 图片内容
        ClipRRect(
          borderRadius: BorderRadius.circular(8),
          child: Image.network(
            image.url,
            fit: BoxFit.cover,
            width: double.infinity,
            height: double.infinity,
            loadingBuilder: (context, child, loadingProgress) {
              if (loadingProgress == null) return child;
              return Center(
                child: CircularProgressIndicator(
                  value: loadingProgress.expectedTotalBytes != null
                      ? loadingProgress.cumulativeBytesLoaded /
                          loadingProgress.expectedTotalBytes!
                      : null,
                ),
              );
            },
          ),
        ),
        
        // 封面标识
        if (image.isCover)
          Positioned(
            top: 4,
            left: 4,
            child: Container(
              padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
              decoration: BoxDecoration(
                color: Colors.amber,
                borderRadius: BorderRadius.circular(4),
              ),
              child: const Row(
                mainAxisSize: MainAxisSize.min,
                children: [
                  Icon(Icons.star, size: 12, color: Colors.white),
                  SizedBox(width: 2),
                  Text(
                    '封面',
                    style: TextStyle(
                      fontSize: 10,
                      color: Colors.white,
                      fontWeight: FontWeight.bold,
                    ),
                  ),
                ],
              ),
            ),
          ),
        
        // 操作按钮
        Positioned(
          top: 4,
          right: 4,
          child: PopupMenuButton<String>(
            icon: Container(
              decoration: BoxDecoration(
                color: Colors.black54,
                borderRadius: BorderRadius.circular(4),
              ),
              padding: const EdgeInsets.all(4),
              child: const Icon(
                Icons.more_vert,
                size: 16,
                color: Colors.white,
              ),
            ),
            itemBuilder: (context) => [
              const PopupMenuItem(
                value: 'set_cover',
                child: Row(
                  children: [
                    Icon(Icons.star, size: 16),
                    SizedBox(width: 8),
                    Text('设为封面'),
                  ],
                ),
              ),
              const PopupMenuItem(
                value: 'delete',
                child: Row(
                  children: [
                    Icon(Icons.delete, size: 16, color: Colors.red),
                    SizedBox(width: 8),
                    Text('删除', style: TextStyle(color: Colors.red)),
                  ],
                ),
              ),
            ],
            onSelected: (value) {
              if (value == 'set_cover') {
                _setImageAsCover(context, image.id);
              } else if (value == 'delete') {
                _deleteImage(context, image.id);
              }
            },
          ),
        ),
        
        // 拖动排序手柄
        Positioned(
          bottom: 4,
          right: 4,
          child: Container(
            decoration: BoxDecoration(
              color: Colors.black54,
              borderRadius: BorderRadius.circular(4),
            ),
            padding: const EdgeInsets.all(4),
            child: const Icon(
              Icons.drag_handle,
              size: 16,
              color: Colors.white,
            ),
          ),
        ),
      ],
    );
  }
  
  /// 显示图片来源选择对话框
  void _showImageSourceDialog(BuildContext context) {
    showModalBottomSheet(
      context: context,
      shape: const RoundedRectangleBorder(
        borderRadius: BorderRadius.vertical(top: Radius.circular(16)),
      ),
      builder: (context) {
        return SafeArea(
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              ListTile(
                leading: const Icon(Icons.camera_alt),
                title: const Text('拍照'),
                onTap: () {
                  Navigator.pop(context);
                  _pickImageFromCamera(context);
                },
              ),
              ListTile(
                leading: const Icon(Icons.photo_library),
                title: const Text('从相册选择'),
                onTap: () {
                  Navigator.pop(context);
                  _pickImageFromGallery(context);
                },
              ),
            ],
          ),
        );
      },
    );
  }
  
  /// 从相机获取图片
  Future<void> _pickImageFromCamera(BuildContext context) async {
    final ImagePicker picker = ImagePicker();
    final XFile? image = await picker.pickImage(
      source: ImageSource.camera,
      maxWidth: 1920,
      maxHeight: 1080,
      imageQuality: 85,
    );
    
    if (image != null) {
      context.read<HouseEditBloc>().add(
        HouseEditImageUploadRequested(imageFiles: [image]),
      );
    }
  }
  
  /// 从相册获取图片
  Future<void> _pickImageFromGallery(BuildContext context) async {
    final ImagePicker picker = ImagePicker();
    final List<XFile> images = await picker.pickMultiImage(
      maxWidth: 1920,
      maxHeight: 1080,
      imageQuality: 85,
    );
    
    if (images.isNotEmpty) {
      context.read<HouseEditBloc>().add(
        HouseEditImageUploadRequested(imageFiles: images),
      );
    }
  }
  
  /// 设置图片为封面
  void _setImageAsCover(BuildContext context, String imageId) {
    // 实现设置封面逻辑
  }
  
  /// 删除图片
  void _deleteImage(BuildContext context, String imageId) {
    showDialog(
      context: context,
      builder: (context) {
        return AlertDialog(
          title: const Text('删除图片'),
          content: const Text('确定要删除这张图片吗？此操作不可撤销。'),
          actions: [
            TextButton(
              onPressed: () => Navigator.pop(context),
              child: const Text('取消'),
            ),
            TextButton(
              onPressed: () {
                Navigator.pop(context);
                context.read<HouseEditBloc>().add(
                  HouseEditImageDeleteRequested(imageId),
                );
              },
              child: const Text(
                '删除',
                style: TextStyle(color: Colors.red),
              ),
            ),
          ],
        );
      },
    );
  }
}

五、HarmonyOS原生能力集成

5.1 HarmonyOS地图定位集成

/// 文件路径：lib/ui/house_edit/tabs/location_tab.dart
/// 
/// 位置信息组件
/// 集成HarmonyOS地图和定位服务

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_form_builder/flutter_form_builder.dart';

class LocationTab extends StatefulWidget {
  final Map<String, dynamic>? formData;
  
  const LocationTab({Key? key, this.formData}) : super(key: key);
  
  @override
  _LocationTabState createState() => _LocationTabState();
}

class _LocationTabState extends State<LocationTab> {
  static const MethodChannel _locationChannel = 
      MethodChannel('com.xiangjia.community/location');
  static const MethodChannel _mapChannel = 
      MethodChannel('com.xiangjia.community/map');
  
  String _currentAddress = '';
  double? _latitude;
  double? _longitude;
  
  @override
  void initState() {
    super.initState();
    _initializeLocation();
  }
  
  /// 初始化位置信息
  Future<void> _initializeLocation() async {
    try {
      // 尝试从表单数据中获取位置信息
      if (widget.formData?['latitude'] != null && 
          widget.formData?['longitude'] != null) {
        _latitude = widget.formData!['latitude'];
        _longitude = widget.formData!['longitude'];
        _currentAddress = widget.formData!['address'] ?? '';
      } else {
        // 获取当前位置
        await _getCurrentLocation();
      }
    } on PlatformException catch (e) {
      print('位置初始化失败: ${e.message}');
    }
  }
  
  /// 获取当前位置
  Future<void> _getCurrentLocation() async {
    try {
      final result = await _locationChannel.invokeMethod('getCurrentLocation');
      
      if (result != null) {
        setState(() {
          _latitude = result['latitude'];
          _longitude = result['longitude'];
          _currentAddress = result['address'] ?? '';
        });
        
        // 更新表单数据
        _updateFormData();
      }
    } on PlatformException catch (e) {
      _showLocationError(e.message ?? '获取位置失败');
    }
  }
  
  /// 更新表单数据
  void _updateFormData() {
    final form = FormBuilder.of(context);
    if (form != null) {
      form.fields['latitude']?.didChange(_latitude);
      form.fields['longitude']?.didChange(_longitude);
      form.fields['address']?.didChange(_currentAddress);
    }
  }
  
  /// 在地图上选择位置
  Future<void> _pickLocationOnMap() async {
    try {
      final result = await _mapChannel.invokeMethod('pickLocation', {
        'initialLatitude': _latitude,
        'initialLongitude': _longitude,
      });
      
      if (result != null) {
        setState(() {
          _latitude = result['latitude'];
          _longitude = result['longitude'];
          _currentAddress = result['address'];
        });
        
        _updateFormData();
      }
    } on PlatformException catch (e) {
      _showLocationError(e.message ?? '地图选择失败');
    }
  }
  
  /// 搜索地址
  Future<void> _searchAddress() async {
    final result = await showSearch(
      context: context,
      delegate: AddressSearchDelegate(),
    );
    
    if (result != null) {
      setState(() {
        _currentAddress = result['address'];
        _latitude = result['latitude'];
        _longitude = result['longitude'];
      });
      
      _updateFormData();
    }
  }
  
  void _showLocationError(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Text(message),
        backgroundColor: Theme.of(context).colorScheme.error,
      ),
    );
  }
  
  @override
  Widget build(BuildContext context) {
    return SingleChildScrollView(
      padding: const EdgeInsets.all(16),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          // 地址搜索
          _buildAddressSearch(),
          const SizedBox(height: 20),
          
          // 地图预览
          if (_latitude != null && _longitude != null)
            _buildMapPreview(),
          
          // 隐藏的表单字段
          FormBuilderTextField(
            name: 'address',
            initialValue: _currentAddress,
            decoration: const InputDecoration.collapsed(hintText: ''),
          ),
          FormBuilderTextField(
            name: 'latitude',
            initialValue: _latitude?.toString(),
            decoration: const InputDecoration.collapsed(hintText: ''),
          ),
          FormBuilderTextField(
            name: 'longitude',
            initialValue: _longitude?.toString(),
            decoration: const InputDecoration.collapsed(hintText: ''),
          ),
        ],
      ),
    );
  }
  
  /// 构建地址搜索组件
  Widget _buildAddressSearch() {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Text(
          '房源位置',
          style: TextStyle(
            fontSize: 14,
            fontWeight: FontWeight.w500,
            color: Colors.grey[700],
          ),
        ),
        const SizedBox(height: 8),
        
        // 地址显示和操作按钮
        Container(
          padding: const EdgeInsets.all(12),
          decoration: BoxDecoration(
            border: Border.all(color: Colors.grey[300]!),
            borderRadius: BorderRadius.circular(8),
          ),
          child: Column(
            children: [
              if (_currentAddress.isNotEmpty)
                Text(
                  _currentAddress,
                  style: const TextStyle(fontSize: 16),
                )
              else
                const Text(
                  '未设置位置',
                  style: TextStyle(color: Colors.grey),
                ),
              const SizedBox(height: 12),
              Row(
                children: [
                  Expanded(
                    child: OutlinedButton.icon(
                      onPressed: _getCurrentLocation,
                      icon: const Icon(Icons.my_location),
                      label: const Text('当前位置'),
                    ),
                  ),
                  const SizedBox(width: 8),
                  Expanded(
                    child: OutlinedButton.icon(
                      onPressed: _pickLocationOnMap,
                      icon: const Icon(Icons.map),
                      label: const Text('地图选点'),
                    ),
                  ),
                  const SizedBox(width: 8),
                  Expanded(
                    child: OutlinedButton.icon(
                      onPressed: _searchAddress,
                      icon: const Icon(Icons.search),
                      label: const Text('搜索地址'),
                    ),
                  ),
                ],
              ),
            ],
          ),
        ),
      ],
    );
  }
  
  /// 构建地图预览
  Widget _buildMapPreview() {
    return SizedBox(
      height: 200,
      child: Stack(
        children: [
          // HarmonyOS地图组件
          Container(
            decoration: BoxDecoration(
              border: Border.all(color: Colors.grey[300]!),
              borderRadius: BorderRadius.circular(8),
              color: Colors.grey[200],
            ),
            child: const Center(
              child: Icon(Icons.map, size: 48, color: Colors.grey),
            ),
          ),
          Positioned(
            bottom: 8,
            right: 8,
            child: FloatingActionButton.small(
              onPressed: _pickLocationOnMap,
              child: const Icon(Icons.edit_location),
            ),
          ),
        ],
      ),
    );
  }
}

六、数据模型定义

6.1 房屋数据模型

/// 文件路径：lib/models/house_model.dart
/// 
/// 房屋数据模型定义
/// 符合HarmonyOS数据规范

class House {
  final String id;
  final String title;
  final String type;
  final double area;
  final double usableArea;
  final int bedrooms;
  final int livingRooms;
  final int bathrooms;
  final int balconies;
  final List<String> orientations;
  final String description;
  final double price;
  final String priceUnit;
  final String address;
  final double latitude;
  final double longitude;
  final DateTime createdAt;
  final DateTime updatedAt;
  final String ownerId;
  final HouseStatus status;
  
  House({
    required this.id,
    required this.title,
    required this.type,
    required this.area,
    required this.usableArea,
    required this.bedrooms,
    required this.livingRooms,
    required this.bathrooms,
    required this.balconies,
    required this.orientations,
    required this.description,
    required this.price,
    required this.priceUnit,
    required this.address,
    required this.latitude,
    required this.longitude,
    required this.createdAt,
    required this.updatedAt,
    required this.ownerId,
    required this.status,
  });
  
  /// 从JSON创建房屋对象
  factory House.fromJson(Map<String, dynamic> json) {
    return House(
      id: json['id'],
      title: json['title'],
      type: json['type'],
      area: (json['area'] as num).toDouble(),
      usableArea: (json['usable_area'] as num).toDouble(),
      bedrooms: json['bedrooms'],
      livingRooms: json['living_rooms'],
      bathrooms: json['bathrooms'],
      balconies: json['balconies'],
      orientations: List<String>.from(json['orientations']),
      description: json['description'],
      price: (json['price'] as num).toDouble(),
      priceUnit: json['price_unit'],
      address: json['address'],
      latitude: (json['latitude'] as num).toDouble(),
      longitude: (json['longitude'] as num).toDouble(),
      createdAt: DateTime.parse(json['created_at']),
      updatedAt: DateTime.parse(json['updated_at']),
      ownerId: json['owner_id'],
      status: HouseStatus.values.firstWhere(
        (e) => e.toString().split('.').last == json['status'],
        orElse: () => HouseStatus.pending,
      ),
    );
  }
  
  /// 转换为JSON
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'title': title,
      'type': type,
      'area': area,
      'usable_area': usableArea,
      'bedrooms': bedrooms,
      'living_rooms': livingRooms,
      'bathrooms': bathrooms,
      'balconies': balconies,
      'orientations': orientations,
      'description': description,
      'price': price,
      'price_unit': priceUnit,
      'address': address,
      'latitude': latitude,
      'longitude': longitude,
      'created_at': createdAt.toIso8601String(),
      'updated_at': updatedAt.toIso8601String(),
      'owner_id': ownerId,
      'status': status.toString().split('.').last,
    };
  }
  
  /// 创建副本并更新字段
  House copyWith({
    String? id,
    String? title,
    String? type,
    double? area,
    double? usableArea,
    int? bedrooms,
    int? livingRooms,
    int? bathrooms,
    int? balconies,
    List<String>? orientations,
    String? description,
    double? price,
    String? priceUnit,
    String? address,
    double? latitude,
    double? longitude,
    DateTime? createdAt,
    DateTime? updatedAt,
    String? ownerId,
    HouseStatus? status,
  }) {
    return House(
      id: id ?? this.id,
      title: title ?? this.title,
      type: type ?? this.type,
      area: area ?? this.area,
      usableArea: usableArea ?? this.usableArea,
      bedrooms: bedrooms ?? this.bedrooms,
      livingRooms: livingRooms ?? this.livingRooms,
      bathrooms: bathrooms ?? this.bathrooms,
      balconies: balconies ?? this.balconies,
      orientations: orientations ?? this.orientations,
      description: description ?? this.description,
      price: price ?? this.price,
      priceUnit: priceUnit ?? this.priceUnit,
      address: address ?? this.address,
      latitude: latitude ?? this.latitude,
      longitude: longitude ?? this.longitude,
      createdAt: createdAt ?? this.createdAt,
      updatedAt: updatedAt ?? this.updatedAt,
      ownerId: ownerId ?? this.ownerId,
      status: status ?? this.status,
    );
  }
}

/// 房屋图片模型
class HouseImage {
  final String id;
  final String houseId;
  final String url;
  final bool isCover;
  final int sortOrder;
  final DateTime createdAt;
  
  HouseImage({
    required this.id,
    required this.houseId,
    required this.url,
    this.isCover = false,
    this.sortOrder = 0,
    required this.createdAt,
  });
}

/// 房屋状态枚举
enum HouseStatus {
  pending,    // 待审核
  approved,   // 已审核
  rejected,   // 已拒绝
  rented,     // 已出租
  sold,       // 已出售
  hidden,     // 已隐藏
}

七、性能优化策略

7.1 编辑性能优化

/// 文件路径：lib/utils/edit_performance_optimizer.dart
/// 
/// 编辑性能优化工具类
/// 提升表单编辑和图片处理的性能

import 'dart:async';
import 'dart:io';
import 'package:flutter/foundation.dart';

class EditPerformanceOptimizer {
  
  /// 图片压缩和优化
  static Future<List<File>> optimizeImages(
    List<File> originalImages,
    int maxWidth,
    int quality,
  ) async {
    final optimizedImages = <File>[];
    
    // 在Isolate中执行图片压缩，避免阻塞UI
    for (final image in originalImages) {
      final optimized = await compute(
        _compressImageInIsolate,
        _CompressImageParams(
          imagePath: image.path,
          maxWidth: maxWidth,
          quality: quality,
        ),
      );
      
      optimizedImages.add(File(optimized));
    }
    
    return optimizedImages;
  }
  
  /// Isolate中的图片压缩函数
  static String _compressImageInIsolate(_CompressImageParams params) {
    // 实际图片压缩逻辑
    // 返回压缩后的图片路径
    return params.imagePath; // 简化实现
  }
  
  /// 表单数据防抖保存
  static Function debounceSave(Function saveFunction, Duration duration) {
    Timer? timer;
    
    return () {
      if (timer != null) {
        timer!.cancel();
      }
      
      timer = Timer(duration, () {
        saveFunction();
      });
    };
  }
  
  /// 内存使用监控
  static void monitorMemoryUsage() {
    // 监听内存压力
    MemoryPressure.addListener((level) {
      switch (level) {
        case MemoryPressureLevel.low:
          _handleLowMemoryPressure();
          break;
        case MemoryPressureLevel.medium:
          _handleMediumMemoryPressure();
          break;
        case MemoryPressureLevel.high:
          _handleHighMemoryPressure();
          break;
      }
    });
  }
  
  static void _handleLowMemoryPressure() {
    // 低内存压力，正常操作
  }
  
  static void _handleMediumMemoryPressure() {
    // 中等内存压力，清理缓存
    imageCache.clear();
    imageCache.clearLiveImages();
  }
  
  static void _handleHighMemoryPressure() {
    // 高内存压力，释放更多资源
    _handleMediumMemoryPressure();
    // 其他资源清理逻辑
  }
}

/// 图片压缩参数
class _CompressImageParams {
  final String imagePath;
  final int maxWidth;
  final int quality;
  
  _CompressImageParams({
    required this.imagePath,
    required this.maxWidth,
    required this.quality,
  });
}

/// 懒加载表单字段
class LazyFormBuilder extends StatefulWidget {
  final Widget child;
  final bool shouldBuild;
  
  const LazyFormBuilder({
    Key? key,
    required this.child,
    this.shouldBuild = true,
  }) : super(key: key);
  
  @override
  _LazyFormBuilderState createState() => _LazyFormBuilderState();
}

class _LazyFormBuilderState extends State<LazyFormBuilder> {
  @override
  Widget build(BuildContext context) {
    return widget.shouldBuild ? widget.child : const SizedBox();
  }
}

八、测试策略

8.1 编辑功能单元测试

/// 文件路径：test/house_edit/house_edit_bloc_test.dart
/// 
/// 房屋编辑BLoC单元测试

import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'package:xiangjia_community/bloc/house_edit/house_edit_bloc.dart';
import 'package:xiangjia_community/models/house_model.dart';
import 'package:xiangjia_community/repositories/house_repository.dart';

@GenerateMocks([HouseRepository])
void main() {
  late MockHouseRepository mockHouseRepository;
  late HouseEditBloc houseEditBloc;
  
  setUp(() {
    mockHouseRepository = MockHouseRepository();
    houseEditBloc = HouseEditBloc(
      houseRepository: mockHouseRepository,
      imagePicker: ImagePicker(),
    );
  });
  
  tearDown(() {
    houseEditBloc.close();
  });
  
  group('HouseEditBloc加载测试', () {
    final mockHouse = House(
      id: 'test_house_1',
      title: '测试房源',
      type: 'apartment',
      area: 85.0,
      usableArea: 70.0,
      bedrooms: 2,
      livingRooms: 1,
      bathrooms: 1,
      balconies: 1,
      orientations: ['南', '北'],
      description: '测试描述',
      price: 3500.0,
      priceUnit: 'month',
      address: '测试地址',
      latitude: 39.9042,
      longitude: 116.4074,
      createdAt: DateTime.now(),
      updatedAt: DateTime.now(),
      ownerId: 'user_1',
      status: HouseStatus.approved,
    );
    
    blocTest<HouseEditBloc, HouseEditState>(
      '加载房屋数据成功',
      build: () {
        when(mockHouseRepository.getHouse('test_house_1'))
            .thenAnswer((_) async => mockHouse);
        return houseEditBloc;
      },
      act: (bloc) => bloc.add(HouseEditLoadRequested('test_house_1')),
      expect: () => [
        HouseEditState(status: HouseEditStatus.loading),
        HouseEditState(
          status: HouseEditStatus.loaded,
          house: mockHouse,
          formData: isA<Map<String, dynamic>>(),
        ),
      ],
    );
  });
  
  group('HouseEditBloc保存测试', () {
    final formData = {
      'title': '测试房源',
      'type': 'apartment',
      'area': '85',
      'usable_area': '70',
      'bedrooms': '2',
      'living_rooms': '1',
      'bathrooms': '1',
      'balconies': '1',
      'orientations': ['南', '北'],
      'description': '测试描述',
      'price': '3500',
      'price_unit': 'month',
    };
    
    blocTest<HouseEditBloc, HouseEditState>(
      '创建新房源成功',
      build: () {
        when(mockHouseRepository.createHouse(any))
            .thenAnswer((_) async => House(
                  id: 'new_house_1',
                  title: '测试房源',
                  type: 'apartment',
                  area: 85.0,
                  usableArea: 70.0,
                  bedrooms: 2,
                  livingRooms: 1,
                  bathrooms: 1,
                  balconies: 1,
                  orientations: ['南', '北'],
                  description: '测试描述',
                  price: 3500.0,
                  priceUnit: 'month',
                  address: '',
                  latitude: 0,
                  longitude: 0,
                  createdAt: DateTime.now(),
                  updatedAt: DateTime.now(),
                  ownerId: 'user_1',
                  status: HouseStatus.pending,
                ));
        return houseEditBloc;
      },
      act: (bloc) => bloc.add(HouseEditSaveRequested(
        houseId: null,
        formData: formData,
      )),
      expect: () => [
        HouseEditState(status: HouseEditStatus.saving),
        HouseEditState(
          status: HouseEditStatus.saveSuccess,
          house: isA<House>(),
        ),
      ],
    );
  });
}

九、部署与监控

9.1 编辑功能监控指标

监控指标	目标值	报警阈值	优化措施
表单加载时间	< 1秒	> 2秒	优化数据查询，增加缓存
图片上传速度	> 500KB/s	< 100KB/s	压缩图片，分片上传
保存成功率	> 99%	< 95%	优化网络重试机制
内存使用峰值	< 150MB	> 200MB	优化图片缓存策略
用户编辑时长	3-5分钟	> 10分钟	简化表单流程

9.2 性能对比图

十、总结

通过本文的实现方案，"享家社区"HarmonyOS APP的房屋编辑功能实现了以下特点：

1. 用户体验优秀：采用鸿蒙设计规范，提供流畅的表单编辑体验
2. 功能完整：覆盖房源编辑的所有关键环节，支持图片、位置等复杂数据
3. 性能高效：通过懒加载、图片优化等技术确保编辑流畅
4. 架构清晰：采用BLoC状态管理，代码可维护性强
5. HarmonyOS集成：充分利用HarmonyOS原生能力，提供更好的设备适配

该实现方案为Flutter在HarmonyOS平台上的复杂表单编辑功能提供了完整的参考实现，具有良好的可扩展性和维护性。

如果您有任何疑问、对文章写的不满意、发现错误或者有更好的方法，欢迎在评论、私信或邮件中提出，非常感谢您的支持。🙏
嘻嘻嘻，关注我！！！黑马波哥