第一章：技术融合时代的跨平台开发新范式

1.1 行业背景与挑战

在数字经济高速发展的今天，“共享经济”已成为连接社会资源与用户需求的重要桥梁。共享社区类应用作为这一模式的重要载体，面临着多维度挑战：

挑战维度	具体表现	技术影响
设备碎片化	Android/iOS/HarmonyOS多系统并存	开发成本倍增，维护困难
用户体验差异	不同平台交互习惯不同	界面和交互需要分别适配
开发效率瓶颈	多团队重复开发相同功能	资源浪费，版本同步困难
生态融合需求	需要接入各平台特有能力	技术整合复杂度高
数据同步难题	跨平台数据一致性维护	架构设计复杂

面对这些挑战，Flutter与HarmonyOS的技术融合提供了创新解决方案。Flutter作为谷歌推出的高性能跨平台框架，其“一次编写，多端运行”的理念与共享社区的快速迭代、多端覆盖需求高度契合。而HarmonyOS作为华为推出的分布式操作系统，为共享社区应用提供了设备协同、场景智能的新可能。

如果您有任何疑问、对文章写的不满意、发现错误或者有更好的方法，欢迎在评论、私信或邮件中提出，非常感谢您的支持。🙏
嘻嘻嘻，关注我！！！黑马波哥
也可以关注我的抖音号: 黑马程序员burger(50696424331) 在直播间交流(18:00-21:00)

1.2 技术选型分析

Flutter的核心优势：

// Flutter技术优势的代码体现
class FlutterAdvantages {
  // 1. 高性能渲染引擎
  static const renderingEngine = {
    'skia': '谷歌2D图形库',
    'impeller': '新一代渲染引擎',
    'frame_rate': '支持120fps',
  };
  
  // 2. 热重载开发体验
  static const developmentExperience = {
    'hot_reload': '毫秒级代码更新',
    'hot_restart': '保持应用状态重启',
    'dev_tools': '完善的调试工具链',
  };
  
  // 3. 丰富的组件生态
  static const componentEcosystem = {
    'material': 'Material Design组件',
    'cupertino': 'iOS风格组件',
    'widgets': '超2000+内置组件',
    'packages': 'pub.dev上23000+插件',
  };
  
  // 4. 跨平台一致性
  static const crossPlatformConsistency = {
    'code_reuse': '单一代码库，复用率85%+',
    'ui_consistency': '像素级视觉一致性',
    'logic_unification': '业务逻辑统一维护',
  };
}

HarmonyOS的独特价值：

class HarmonyOSValue {
  // 1. 分布式能力
  static const distributedCapabilities = {
    'soft_bus': '分布式软总线技术',
    'data_sync': '跨设备数据同步',
    'task_migration': '任务无缝迁移',
    'device_pool': '虚拟超级设备池',
  };
  
  // 2. 原子化服务
  static const atomicServices = {
    'service_cards': '服务卡片直达',
    'cross_app': '应用免安装运行',
    'intent_based': '意图驱动服务',
    'one_hop_service': '一键直达服务',
  };
  
  // 3. 原生性能优势
  static const nativePerformance = {
    'ark_compiler': '方舟编译器优化',
    'deterministic_latency': '确定时延引擎',
    'unified_os': '统一操作系统',
    'native_experience': '原生级用户体验',
  };
}

第二章：一体化架构设计

2.1 整体架构概览

┌─────────────────────────────────────────────────────────┐
│                  共享社区应用层 (Sharing Community App)     │
├─────────────────────────────────────────────────────────┤
│  Flutter业务层 (Dart)                                    │
│  ┌─────────────────────────────────────────────────┐   │
│  │  表现层 (Presentation Layer)                     │   │
│  │  • 共享物品展示组件                               │   │
│  │  • 社区互动界面                                   │   │
│  │  • 交易流程页面                                   │   │
│  └─────────────────────────────────────────────────┘   │
│  ┌─────────────────────────────────────────────────┐   │
│  │  业务逻辑层 (Business Logic Layer)               │   │
│  │  • BLoC/Provider状态管理                         │   │
│  │  • 共享匹配算法                                   │   │
│  │  • 交易处理引擎                                   │   │
│  │  • 社区规则引擎                                   │   │
│  └─────────────────────────────────────────────────┘   │
│  ┌─────────────────────────────────────────────────┐   │
│  │  数据访问层 (Data Access Layer)                  │   │
│  │  • Repository模式                               │   │
│  │  • 本地缓存策略                                   │   │
│  │  • 网络请求封装                                   │   │
│  └─────────────────────────────────────────────────┘   │
├─────────────────────────────────────────────────────────┤
│              平台适配层 (Platform Adaptation)            │
│  ┌─────────────────────────────────────────────────┐   │
│  │  Flutter Platform Channels                      │   │
│  │  • MethodChannel: 方法调用                       │   │
│  │  • EventChannel: 事件监听                        │   │
│  │  • MessageChannel: 消息传递                      │   │
│  └─────────────────────────────────────────────────┘   │
├─────────────────────────────────────────────────────────┤
│             原生能力层 (Native Capabilities)            │
│  ┌──────────────┬──────────────┬──────────────────┐   │
│  │ Android      │ iOS          │ HarmonyOS        │   │
│  │ (Java/Kotlin)│ (Swift/Obj-C)│ (ArkTS/C++)      │   │
│  │ • 系统API    │ • iOS特性    │ • 分布式能力      │   │
│  │ • 硬件访问    │ • 苹果生态   │ • 原子化服务      │   │
│  │ • Google服务 │ • 推送服务   │ • 卡片服务        │   │
│  └──────────────┴──────────────┴──────────────────┘   │
└─────────────────────────────────────────────────────────┘

2.2 核心模块设计

领域模型设计

// 共享社区核心领域模型
part 'sharing_community.g.dart';

@Entity()
class User {
  @PrimaryKey()
  final String id;
  
  final String username;
  final String phone;
  final String avatarUrl;
  final double creditScore; // 信用评分
  final List<String> tags; // 用户标签
  final UserLocation location;
  final DateTime joinTime;
  final UserStatus status;
  
  // HarmonyOS特有属性
  final String? harmonyUid;
  final List<String> harmonyDeviceIds;
  final bool harmonyAccountLinked;
  
  User({
    required this.id,
    required this.username,
    required this.phone,
    required this.avatarUrl,
    this.creditScore = 100.0,
    this.tags = const [],
    required this.location,
    required this.joinTime,
    this.status = UserStatus.active,
    this.harmonyUid,
    this.harmonyDeviceIds = const [],
    this.harmonyAccountLinked = false,
  });
}

@Entity()
class SharedItem {
  @PrimaryKey()
  final String id;
  
  final String title;
  final String description;
  final ItemCategory category;
  final List<String> imageUrls;
  final double pricePerDay;
  final GeoLocation location;
  final String ownerId;
  final DateTime publishTime;
  final ItemStatus status;
  
  // 物品属性
  final Map<String, dynamic> specifications;
  final List<String> features;
  final List<TimeSlot> availableSlots;
  
  // 共享规则
  final int minRentalDays;
  final int maxRentalDays;
  final double depositAmount;
  final List<String> usageRules;
  
  // HarmonyOS兼容性
  final bool isHarmonyCompatible;
  final List<HarmonyCapability> requiredCapabilities;
  final String? harmonyDeviceId; // 如果是HarmonyOS智能设备
  
  SharedItem({
    required this.id,
    required this.title,
    required this.description,
    required this.category,
    required this.imageUrls,
    required this.pricePerDay,
    required this.location,
    required this.ownerId,
    required this.publishTime,
    required this.status,
    this.specifications = const {},
    this.features = const [],
    this.availableSlots = const [],
    this.minRentalDays = 1,
    this.maxRentalDays = 30,
    this.depositAmount = 0.0,
    this.usageRules = const [],
    this.isHarmonyCompatible = false,
    this.requiredCapabilities = const [],
    this.harmonyDeviceId,
  });
}

@Entity()
class Transaction {
  @PrimaryKey()
  final String id;
  
  final String itemId;
  final String borrowerId;
  final String lenderId;
  final DateTime startTime;
  final DateTime endTime;
  final double totalAmount;
  final double depositAmount;
  final TransactionStatus status;
  final PaymentInfo payment;
  
  // 物流信息
  final DeliveryInfo? deliveryInfo;
  final DateTime? actualStartTime;
  final DateTime? actualEndTime;
  
  // 评价与反馈
  final Rating? borrowerRating;
  final Rating? lenderRating;
  final String? feedback;
  
  // HarmonyOS设备访问
  final DeviceAccessToken? deviceAccessToken;
  final List<DeviceControlLog> controlLogs;
  
  Transaction({
    required this.id,
    required this.itemId,
    required this.borrowerId,
    required this.lenderId,
    required this.startTime,
    required this.endTime,
    required this.totalAmount,
    required this.depositAmount,
    required this.status,
    required this.payment,
    this.deliveryInfo,
    this.actualStartTime,
    this.actualEndTime,
    this.borrowerRating,
    this.lenderRating,
    this.feedback,
    this.deviceAccessToken,
    this.controlLogs = const [],
  });
}

状态管理设计

// 基于BLoC的状态管理架构
abstract class SharingEvent {}

abstract class SharingState {}

// 物品管理相关事件
class LoadItemsEvent extends SharingEvent {
  final GeoLocation? location;
  final double? radius;
  final ItemCategory? category;
  
  LoadItemsEvent({this.location, this.radius, this.category});
}

class PublishItemEvent extends SharingEvent {
  final SharedItem item;
  final List<MultipartFile> images;
  
  PublishItemEvent({required this.item, required this.images});
}

class RentItemEvent extends SharingEvent {
  final String itemId;
  final DateTime startTime;
  final DateTime endTime;
  
  RentItemEvent({
    required this.itemId,
    required this.startTime,
    required this.endTime,
  });
}

// 状态定义
class ItemsLoadingState extends SharingState {
  final double progress;
  
  ItemsLoadingState({this.progress = 0.0});
}

class ItemsLoadedState extends SharingState {
  final List<SharedItem> items;
  final bool hasMore;
  final int totalCount;
  
  ItemsLoadedState({
    required this.items,
    this.hasMore = true,
    this.totalCount = 0,
  });
}

class TransactionProcessingState extends SharingState {
  final String transactionId;
  final TransactionStep currentStep;
  final String message;
  
  TransactionProcessingState({
    required this.transactionId,
    required this.currentStep,
    required this.message,
  });
}

// BLoC实现
class SharingBloc extends Bloc<SharingEvent, SharingState> {
  final ItemRepository itemRepository;
  final TransactionRepository transactionRepository;
  final LocationService locationService;
  final HarmonyService harmonyService;
  
  SharingBloc({
    required this.itemRepository,
    required this.transactionRepository,
    required this.locationService,
    required this.harmonyService,
  }) : super(ItemsLoadingState()) {
    // 注册事件处理器
    on<LoadItemsEvent>(_onLoadItems);
    on<PublishItemEvent>(_onPublishItem);
    on<RentItemEvent>(_onRentItem);
    on<SyncWithHarmonyEvent>(_onSyncWithHarmony);
  }
  
  Future<void> _onLoadItems(
    LoadItemsEvent event,
    Emitter<SharingState> emit,
  ) async {
    emit(ItemsLoadingState(progress: 0.1));
    
    try {
      // 获取位置信息
      final location = event.location ?? 
          await locationService.getCurrentLocation();
      
      emit(ItemsLoadingState(progress: 0.3));
      
      // 查询物品
      final items = await itemRepository.getNearbyItems(
        location: location,
        radius: event.radius ?? 5.0, // 默认5公里
        category: event.category,
      );
      
      emit(ItemsLoadingState(progress: 0.7));
      
      // HarmonyOS设备：筛选兼容设备
      List<SharedItem> filteredItems = items;
      if (Platform.isHarmonyOS) {
        final deviceCapabilities = await harmonyService.getCapabilities();
        filteredItems = items.where((item) {
          return !item.isHarmonyCompatible || 
                 _checkCompatibility(item, deviceCapabilities);
        }).toList();
      }
      
      emit(ItemsLoadingState(progress: 1.0));
      emit(ItemsLoadedState(
        items: filteredItems,
        totalCount: filteredItems.length,
      ));
    } catch (e) {
      emit(ItemsErrorState(error: e.toString()));
    }
  }
  
  Future<void> _onRentItem(
    RentItemEvent event,
    Emitter<SharingState> emit,
  ) async {
    emit(TransactionProcessingState(
      transactionId: 'pending',
      currentStep: TransactionStep.validating,
      message: '正在验证交易信息...',
    ));
    
    try {
      // 1. 验证物品可用性
      final item = await itemRepository.getItem(event.itemId);
      if (!item.isAvailable(event.startTime, event.endTime)) {
        throw Exception('物品在该时间段不可用');
      }
      
      emit(TransactionProcessingState(
        transactionId: 'pending',
        currentStep: TransactionStep.calculating,
        message: '正在计算费用...',
      ));
      
      // 2. 计算费用
      final totalAmount = _calculateTotalAmount(
        item.pricePerDay,
        event.startTime,
        event.endTime,
      );
      
      // 3. 创建交易记录
      final transaction = await transactionRepository.createTransaction(
        itemId: event.itemId,
        borrowerId: await _getCurrentUserId(),
        startTime: event.startTime,
        endTime: event.endTime,
        totalAmount: totalAmount,
      );
      
      emit(TransactionProcessingState(
        transactionId: transaction.id,
        currentStep: TransactionStep.payment,
        message: '请完成支付...',
      ));
      
      // 4. 如果是HarmonyOS设备，请求设备访问权限
      if (item.isHarmonyCompatible && item.harmonyDeviceId != null) {
        await _requestHarmonyDeviceAccess(
          transaction.id,
          item.harmonyDeviceId!,
          event.startTime,
          event.endTime,
        );
      }
      
      // 5. 更新状态
      emit(TransactionCreatedState(transaction: transaction));
      
    } catch (e) {
      emit(TransactionErrorState(
        error: e.toString(),
        transactionId: event.itemId,
      ));
    }
  }
  
  Future<void> _onSyncWithHarmony(
    SyncWithHarmonyEvent event,
    Emitter<SharingState> emit,
  ) async {
    if (!Platform.isHarmonyOS) return;
    
    emit(HarmonySyncState(
      status: SyncStatus.inProgress,
      progress: 0.0,
      message: '开始同步HarmonyOS设备...',
    ));
    
    try {
      // 1. 发现附近的HarmonyOS设备
      final nearbyDevices = await harmonyService.discoverDevices();
      
      emit(HarmonySyncState(
        status: SyncStatus.inProgress,
        progress: 0.3,
        message: '发现${nearbyDevices.length}个设备',
      ));
      
      // 2. 筛选可共享的设备
      final sharableDevices = nearbyDevices.where((device) {
        return device.isSharable && 
               device.ownerId == await _getCurrentUserId();
      }).toList();
      
      emit(HarmonySyncState(
        status: SyncStatus.inProgress,
        progress: 0.6,
        message: '${sharableDevices.length}个设备可共享',
      ));
      
      // 3. 同步到共享物品库
      for (final device in sharableDevices) {
        final existingItem = await itemRepository.getItemByDeviceId(device.id);
        
        if (existingItem == null) {
          // 创建新的共享物品
          final newItem = SharedItem(
            id: device.id,
            title: device.name,
            description: '智能${device.type}设备',
            category: ItemCategory.electronics,
            imageUrls: [device.imageUrl],
            pricePerDay: _calculateDevicePrice(device),
            location: await locationService.getCurrentLocation(),
            ownerId: device.ownerId,
            publishTime: DateTime.now(),
            status: ItemStatus.available,
            isHarmonyCompatible: true,
            requiredCapabilities: device.capabilities,
            harmonyDeviceId: device.id,
          );
          
          await itemRepository.publishItem(newItem);
        }
      }
      
      emit(HarmonySyncState(
        status: SyncStatus.completed,
        progress: 1.0,
        message: '设备同步完成',
        synchronizedDevices: sharableDevices.length,
      ));
      
    } catch (e) {
      emit(HarmonySyncState(
        status: SyncStatus.failed,
        progress: 0.0,
        message: '同步失败: $e',
      ));
    }
  }
}

第三章：Flutter-HarmonyOS深度集成

3.1 平台通道增强设计

// 增强型平台通道管理器
class EnhancedPlatformChannel {
  // 单例实例
  static final EnhancedPlatformChannel _instance = 
      EnhancedPlatformChannel._internal();
  
  factory EnhancedPlatformChannel() => _instance;
  
  // 通道定义
  final Map<String, MethodChannel> _methodChannels = {};
  final Map<String, EventChannel> _eventChannels = {};
  final Map<String, BasicMessageChannel> _messageChannels = {};
  
  // HarmonyOS特有通道
  MethodChannel? _harmonyMethodChannel;
  EventChannel? _harmonyEventChannel;
  
  EnhancedPlatformChannel._internal() {
    _initializeChannels();
  }
  
  void _initializeChannels() {
    // 基础方法通道
    _methodChannels['main'] = const MethodChannel('com.sharing.community/main');
    _methodChannels['auth'] = const MethodChannel('com.sharing.community/auth');
    _methodChannels['payment'] = const MethodChannel('com.sharing.community/payment');
    _methodChannels['location'] = const MethodChannel('com.sharing.community/location');
    
    // 事件通道
    _eventChannels['network'] = const EventChannel('com.sharing.community/network');
    _eventChannels['location_updates'] = 
        const EventChannel('com.sharing.community/location_updates');
    
    // HarmonyOS特有通道
    if (Platform.isHarmonyOS) {
      _harmonyMethodChannel = 
          const MethodChannel('com.sharing.community/harmony');
      _harmonyEventChannel = 
          const EventChannel('com.sharing.community/harmony_events');
      
      _initializeHarmonyChannels();
    }
    
    // 设置默认处理器
    _setDefaultHandlers();
  }
  
  Future<void> _initializeHarmonyChannels() async {
    if (!Platform.isHarmonyOS) return;
    
    try {
      // 注册HarmonyOS生命周期监听
      await _harmonyMethodChannel!.invokeMethod('registerLifecycleListener');
      
      // 注册分布式数据监听
      await _harmonyMethodChannel!.invokeMethod('registerDataSyncListener');
      
      // 初始化HarmonyOS服务
      await _harmonyMethodChannel!.invokeMethod('initializeServices');
      
      // 监听HarmonyOS事件
      _harmonyEventChannel!.receiveBroadcastStream().listen(_handleHarmonyEvent);
      
      print('HarmonyOS通道初始化成功');
    } catch (e) {
      print('HarmonyOS通道初始化失败: $e');
    }
  }
  
  void _handleHarmonyEvent(dynamic event) {
    try {
      final eventMap = Map<String, dynamic>.from(event);
      final eventType = eventMap['type'];
      
      switch (eventType) {
        case 'device_connected':
          _handleDeviceConnected(eventMap['data']);
          break;
        case 'device_disconnected':
          _handleDeviceDisconnected(eventMap['data']);
          break;
        case 'distributed_data_changed':
          _handleDistributedDataChanged(eventMap['data']);
          break;
        case 'harmony_account_updated':
          _handleHarmonyAccountUpdated(eventMap['data']);
          break;
        case 'service_card_updated':
          _handleServiceCardUpdated(eventMap['data']);
          break;
      }
    } catch (e) {
      print('处理HarmonyOS事件失败: $e');
    }
  }
  
  // HarmonyOS分布式数据同步
  Future<void> syncToHarmonyDistributed(
    String key, 
    dynamic value, {
    SyncPriority priority = SyncPriority.normal,
    SyncScope scope = SyncScope.account,
  }) async {
    if (!Platform.isHarmonyOS) return;
    
    try {
      await _harmonyMethodChannel!.invokeMethod('syncDistributedData', {
        'key': key,
        'value': value,
        'priority': priority.index,
        'scope': scope.index,
        'timestamp': DateTime.now().millisecondsSinceEpoch,
      });
    } catch (e) {
      print('分布式数据同步失败: $e');
    }
  }
  
  // HarmonyOS原子化服务
  Future<ServiceCard> createHarmonyServiceCard({
    required String cardId,
    required String title,
    required CardType type,
    required Map<String, dynamic> data,
    List<CardAction> actions = const [],
  }) async {
    if (!Platform.isHarmonyOS) {
      throw PlatformException(
        code: 'not_supported',
        message: '仅支持HarmonyOS平台',
      );
    }
    
    try {
      final result = await _harmonyMethodChannel!.invokeMethod<Map>(
        'createServiceCard',
        {
          'cardId': cardId,
          'title': title,
          'type': type.index,
          'data': data,
          'actions': actions.map((a) => a.toJson()).toList(),
        },
      );
      
      return ServiceCard.fromJson(result!);
    } catch (e) {
      print('创建服务卡片失败: $e');
      rethrow;
    }
  }
  
  // 跨平台方法调用
  Future<T?> invokePlatformMethod<T>(
    String method, {
    Map<String, dynamic>? arguments,
    PlatformMethodPriority priority = PlatformMethodPriority.normal,
  }) async {
    // 根据平台选择通道
    final channel = _selectChannelForMethod(method);
    
    try {
      if (priority == PlatformMethodPriority.high && Platform.isHarmonyOS) {
        // 高优先级方法使用HarmonyOS原生调用
        return await _invokeHarmonyNative(method, arguments);
      }
      
      return await channel.invokeMethod<T>(method, arguments);
    } catch (e) {
      // 失败时尝试备用方案
      return await _tryFallbackMethod(method, arguments);
    }
  }
  
  MethodChannel _selectChannelForMethod(String method) {
    if (method.startsWith('harmony_') && Platform.isHarmonyOS) {
      return _harmonyMethodChannel!;
    }
    
    // 根据方法前缀选择通道
    if (method.startsWith('auth_')) return _methodChannels['auth']!;
    if (method.startsWith('payment_')) return _methodChannels['payment']!;
    if (method.startsWith('location_')) return _methodChannels['location']!;
    
    return _methodChannels['main']!;
  }
}

// HarmonyOS设备管理
class HarmonyDeviceManager {
  final MethodChannel _channel;
  
  HarmonyDeviceManager() : _channel = const MethodChannel('com.sharing.community/harmony_devices');
  
  // 发现附近设备
  Future<List<HarmonyDevice>> discoverNearbyDevices({
    DiscoveryMode mode = DiscoveryMode.active,
    Duration timeout = const Duration(seconds: 10),
  }) async {
    final result = await _channel.invokeMethod<List>('discoverDevices', {
      'mode': mode.index,
      'timeout': timeout.inMilliseconds,
    });
    
    return (result ?? [])
        .map((e) => HarmonyDevice.fromJson(Map<String, dynamic>.from(e)))
        .toList();
  }
  
  // 控制设备
  Future<void> controlDevice(
    String deviceId,
    DeviceCommand command, {
    Map<String, dynamic>? parameters,
    Duration? timeout,
  }) async {
    await _channel.invokeMethod('controlDevice', {
      'deviceId': deviceId,
      'command': command.toJson(),
      'parameters': parameters,
      'timeout': timeout?.inMilliseconds,
    });
  }
  
  // 获取设备状态
  Future<DeviceStatus> getDeviceStatus(String deviceId) async {
    final result = await _channel.invokeMethod<Map>('getDeviceStatus', {
      'deviceId': deviceId,
    });
    
    return DeviceStatus.fromJson(result!);
  }
  
  // 共享设备访问权限
  Future<DeviceAccessToken> shareDeviceAccess({
    required String deviceId,
    required String recipientId,
    required List<DevicePermission> permissions,
    required DateTime expiresAt,
  }) async {
    final result = await _channel.invokeMethod<Map>('shareDeviceAccess', {
      'deviceId': deviceId,
      'recipientId': recipientId,
      'permissions': permissions.map((p) => p.index).toList(),
      'expiresAt': expiresAt.toIso8601String(),
    });
    
    return DeviceAccessToken.fromJson(result!);
  }
}

3.2 FlutterBoost混合开发架构

// FlutterBoost混合栈管理
class HybridStackManager {
  static final HybridStackManager _instance = HybridStackManager._internal();
  
  factory HybridStackManager() => _instance;
  
  final FlutterBoost _flutterBoost;
  final Map<String, WidgetBuilder> _pageBuilders;
  HarmonyNavigationService? _harmonyNavigation;
  
  HybridStackManager._internal()
      : _flutterBoost = FlutterBoost.instance,
        _pageBuilders = {} {
    _initialize();
  }
  
  Future<void> _initialize() async {
    // 注册FlutterBoost页面
    _registerFlutterPages();
    
    // 初始化FlutterBoost
    await _flutterBoost.setup(
      _createBoostApp(),
      interceptors: [_createBoostInterceptor()],
    );
    
    // HarmonyOS特有初始化
    if (Platform.isHarmonyOS) {
      await _initializeHarmonyNavigation();
    }
  }
  
  Widget _createBoostApp() {
    return MaterialApp(
      title: '共享社区',
      builder: FlutterBoost.init(postPush: _onPostPush),
      home: Container(),
    );
  }
  
  FlutterBoostInterceptor _createBoostInterceptor() {
    return FlutterBoostInterceptor(
      onPush: (options, uniqueId) {
        // 页面跳转前处理
        _onPageWillPush(options);
        return super.onPush(options, uniqueId);
      },
      onPop: (options, uniqueId, result) {
        // 页面返回前处理
        _onPageWillPop(options);
        return super.onPop(options, uniqueId, result);
      },
    );
  }
  
  Future<void> _initializeHarmonyNavigation() async {
    _harmonyNavigation = HarmonyNavigationService();
    
    // 注册HarmonyOS页面路由
    await _harmonyNavigation!.registerRoute(
      '/flutter/:page',
      (context, params) => _buildHarmonyFlutterPage(params),
    );
    
    // 设置导航监听
    _harmonyNavigation!.setOnNavigateListener((route, params) {
      _handleHarmonyNavigation(route, params);
    });
    
    // 配置共享元素转场
    await _harmonyNavigation!.configureSharedElementTransition(
      transitionConfig: HarmonyTransitionConfig(
        duration: 300,
        curve: Curves.easeInOut,
        sharedElements: _getSharedElementMapping(),
      ),
    );
  }
  
  // 统一导航方法
  Future<T?> navigateTo<T>({
    required String route,
    Map<String, dynamic>? arguments,
    bool replace = false,
    bool clearStack = false,
    PageTransition transition = PageTransition.auto,
  }) async {
    // 自动选择最佳导航方式
    final effectiveTransition = transition == PageTransition.auto
        ? _selectBestTransition()
        : transition;
    
    if (effectiveTransition == PageTransition.harmony && Platform.isHarmonyOS) {
      // 使用HarmonyOS原生导航
      return await _harmonyNavigation!.navigateTo(
        route: route,
        arguments: arguments,
        replace: replace,
        clearStack: clearStack,
      );
    } else {
      // 使用FlutterBoost导航
      return await _flutterBoost.open(
        route,
        arguments: arguments,
        withContainer: true,
        opaque: true,
      );
    }
  }
  
  PageTransition _selectBestTransition() {
    if (!Platform.isHarmonyOS) {
      return PageTransition.native;
    }
    
    // 根据页面类型选择转场
    if (_isComplexPage(route)) {
      return PageTransition.flutter;
    } else if (_requiresNativeFeature(route)) {
      return PageTransition.harmony;
    } else {
      return PageTransition.native;
    }
  }
  
  // 处理HarmonyOS返回键
  Future<bool> handleBackPress() async {
    // 检查Flutter页面栈
    if (_flutterBoost.currentContainer != null) {
      final navigator = Navigator.of(_flutterBoost.currentContainer!.context);
      if (navigator.canPop()) {
        navigator.pop();
        return false; // 已处理
      }
    }
    
    // Flutter栈为空，交给系统处理
    return true;
  }
}

// 混合页面组件
class HybridPage extends StatefulWidget {
  final String route;
  final Map<String, dynamic>? params;
  final bool useNativeIfAvailable;
  
  const HybridPage({
    required this.route,
    this.params,
    this.useNativeIfAvailable = true,
  });
  
  @override
  _HybridPageState createState() => _HybridPageState();
}

class _HybridPageState extends State<HybridPage> {
  Widget? _currentPage;
  
  @override
  void initState() {
    super.initState();
    _loadPage();
  }
  
  Future<void> _loadPage() async {
    // 检查是否有原生实现
    if (widget.useNativeIfAvailable && Platform.isHarmonyOS) {
      final nativePage = await _tryLoadNativePage();
      if (nativePage != null) {
        setState(() {
          _currentPage = nativePage;
        });
        return;
      }
    }
    
    // 使用Flutter页面
    final flutterPage = _loadFlutterPage();
    setState(() {
      _currentPage = flutterPage;
    });
  }
  
  Future<Widget?> _tryLoadNativePage() async {
    try {
      // 调用HarmonyOS原生页面
      final result = await MethodChannel('com.sharing.community/pages')
          .invokeMethod<Map>('loadPage', {
        'route': widget.route,
        'params': widget.params,
      });
      
      if (result != null) {
        return HarmonyNativeView(
          viewType: 'harmony_page',
          creationParams: result,
          creationParamsCodec: const StandardMessageCodec(),
        );
      }
    } catch (e) {
      print('加载原生页面失败: $e');
    }
    
    return null;
  }
  
  Widget _loadFlutterPage() {
    // 根据路由加载对应的Flutter页面
    final pageBuilder = HybridStackManager().getPageBuilder(widget.route);
    if (pageBuilder != null) {
      return pageBuilder(context);
    }
    
    // 默认页面
    return Scaffold(
      appBar: AppBar(title: Text(widget.route)),
      body: Center(child: Text('页面未找到: ${widget.route}')),
    );
  }
  
  @override
  Widget build(BuildContext context) {
    return _currentPage ?? const CircularProgressIndicator();
  }
}

第四章：HarmonyOS APP专项开发

4.1 ArkUI组件适配层

// ArkTS端：Flutter组件桥接
import { FlutterBridge } from '@ohos/flutter-bridge'

@Component
struct FlutterComponentAdapter {
  @State componentName: string = ''
  @State componentProps: Object = {}
  @State isNativeSupported: boolean = false
  
  private flutterBridge: FlutterBridge = new FlutterBridge()
  private nativeRenderer: NativeUIRenderer = new NativeUIRenderer()
  
  build() {
    Column() {
      // 条件渲染：优先使用原生组件
      if (this.isNativeSupported && this._shouldUseNative()) {
        this._buildNativeComponent()
      } else {
        // 使用Flutter组件
        FlutterEmbeddedView({
          component: this.componentName,
          props: this.componentProps,
          onEvent: this._handleFlutterEvent.bind(this)
        })
      }
    }
    .onAppear(() => {
      this._checkNativeSupport()
    })
  }
  
  // 检查原生支持
  private async _checkNativeSupport() {
    const nativeComponents = [
      'Button', 'Text', 'Image', 'List', 'Grid', 
      'Swiper', 'Progress', 'Slider', 'Switch'
    ]
    
    this.isNativeSupported = nativeComponents.includes(this.componentName)
    
    // 检查组件复杂度
    if (this.isNativeSupported) {
      const hasComplexAnimation = this._hasComplexAnimation(this.componentProps)
      const requiresCustomPainting = this._requiresCustomPainting(this.componentProps)
      
      if (hasComplexAnimation || requiresCustomPainting) {
        this.isNativeSupported = false
      }
    }
  }
  
  // 构建原生ArkUI组件
  @Builder
  private _buildNativeComponent() {
    switch (this.componentName) {
      case 'Button':
        Button(this.componentProps.label)
          .onClick(() => this._handleNativeClick())
          .backgroundColor(this.componentProps.color)
          .borderRadius(this.componentProps.borderRadius)
        break
        
      case 'List':
        List() {
          ForEach(this.componentProps.items, (item: ListItem) => {
            ListItem() {
              Column() {
                Text(item.title)
                  .fontSize(16)
                if (item.subtitle) {
                  Text(item.subtitle)
                    .fontSize(12)
                    .fontColor(Color.Gray)
                }
              }
              .padding(10)
            }
          })
        }
        break
        
      case 'Card':
        Column() {
          if (this.componentProps.image) {
            Image(this.componentProps.image)
              .width('100%')
              .height(150)
              .objectFit(ImageFit.Cover)
          }
          
          Column() {
            Text(this.componentProps.title)
              .fontSize(18)
              .fontWeight(FontWeight.Bold)
            
            if (this.componentProps.description) {
              Text(this.componentProps.description)
                .fontSize(14)
                .fontColor(Color.Gray)
                .maxLines(2)
            }
          }
          .padding(15)
        }
        .backgroundColor(Color.White)
        .borderRadius(10)
        .shadow({ radius: 5, color: Color.Gray })
        break
    }
  }
  
  // 处理Flutter事件
  private _handleFlutterEvent(event: Object) {
    // 转发到原生事件系统
    this.nativeRenderer.dispatchEvent(event)
    
    // 更新本地状态
    if (event.type === 'state_update') {
      this.componentProps = { ...this.componentProps, ...event.data }
    }
  }
}

// Flutter端：ArkUI组件封装
class ArkUIComponent extends StatelessWidget {
  final String componentName;
  final Map<String, dynamic> properties;
  final ValueChanged<dynamic> onEvent;
  
  const ArkUIComponent({
    required this.componentName,
    required this.properties,
    required this.onEvent,
  });
  
  @override
  Widget build(BuildContext context) {
    if (!Platform.isHarmonyOS) {
      return _buildFlutterFallback(context);
    }
    
    return HarmonyNativeView(
      viewType: 'arkui/$componentName',
      creationParams: _prepareCreationParams(),
      creationParamsCodec: const StandardMessageCodec(),
      onPlatformViewCreated: _onPlatformViewCreated,
    );
  }
  
  Map<String, dynamic> _prepareCreationParams() {
    return {
      'component': componentName,
      'props': properties,
      'config': {
        'enableAnimations': true,
        'useHardwareAcceleration': true,
        'optimizeForPerformance': true,
      },
    };
  }
  
  void _onPlatformViewCreated(int id) {
    final channel = MethodChannel('arkui/$componentName/$id');
    
    // 设置方法调用处理器
    channel.setMethodCallHandler((call) async {
      switch (call.method) {
        case 'onEvent':
          onEvent(call.arguments);
          break;
        case 'getState':
          return properties;
        case 'updateProps':
          // 处理属性更新
          _handlePropsUpdate(call.arguments);
          break;
      }
      return null;
    });
    
    // 初始属性同步
    channel.invokeMethod('initProps', properties);
  }
  
  Widget _buildFlutterFallback(BuildContext context) {
    // 为其他平台提供Flutter实现
    switch (componentName) {
      case 'HarmonyCard':
        return Card(
          child: Column(
            children: [
              if (properties['image'] != null)
                Image.network(properties['image']),
              ListTile(
                title: Text(properties['title'] ?? ''),
                subtitle: properties['description'] != null
                    ? Text(properties['description'])
                    : null,
              ),
            ],
          ),
        );
      default:
        return Container(
          color: Colors.grey[200],
          child: Center(
            child: Text('$componentName (Flutter Fallback)'),
          ),
        );
    }
  }
}

4.2 分布式能力集成

// 分布式共享管理器
class DistributedSharingManager {
  static final DistributedSharingManager _instance = 
      DistributedSharingManager._internal();
  
  factory DistributedSharingManager() => _instance;
  
  final HarmonyDistributedEngine _distributedEngine;
  final Map<String, DistributedSession> _activeSessions = {};
  final Map<String, StreamSubscription> _dataSubscriptions = {};
  
  DistributedSharingManager._internal()
      : _distributedEngine = HarmonyDistributedEngine() {
    _initialize();
  }
  
  Future<void> _initialize() async {
    if (!Platform.isHarmonyOS) return;
    
    try {
      // 初始化分布式引擎
      await _distributedEngine.initialize();
      
      // 注册数据同步监听器
      await _distributedEngine.registerDataSyncListener(
        _handleDataSyncEvent,
      );
      
      // 注册设备状态监听器
      await _distributedEngine.registerDeviceStateListener(
        _handleDeviceStateChange,
      );
      
      print('分布式共享管理器初始化成功');
    } catch (e) {
      print('分布式共享管理器初始化失败: $e');
    }
  }
  
  // 创建分布式共享会话
  Future<DistributedSession> createSharingSession({
    required SharedItem item,
    required List<String> participantIds,
    required SharingMode mode,
    SharingPermissions permissions = SharingPermissions.basic,
  }) async {
    final sessionId = 'session_${DateTime.now().millisecondsSinceEpoch}';
    
    final session = DistributedSession(
      id: sessionId,
      item: item,
      mode: mode,
      creatorId: await _getCurrentUserId(),
      participantIds: participantIds,
      permissions: permissions,
      createdAt: DateTime.now(),
    );
    
    // 创建分布式数据组
    await _distributedEngine.createDataGroup(
      groupId: sessionId,
      config: DistributedGroupConfig(
        name: '共享会话: ${item.title}',
        securityLevel: SecurityLevel.high,
        syncStrategy: DistributedSyncStrategy.realtime,
        conflictResolution: ConflictResolutionStrategy.lastWriteWins,
      ),
    );
    
    // 添加参与者
    for (final participantId in participantIds) {
      await _distributedEngine.addToGroup(
        groupId: sessionId,
        deviceId: participantId,
        permissions: _mapToDistributedPermissions(permissions),
      );
    }
    
    // 同步初始数据
    await _syncSessionData(session);
    
    // 监听数据变化
    await _setupDataMonitoring(sessionId);
    
    _activeSessions[sessionId] = session;
    return session;
  }
  
  // 同步会话数据
  Future<void> _syncSessionData(DistributedSession session) async {
    final syncData = {
      'session_id': session.id,
      'item': session.item.toJson(),
      'mode': session.mode.index,
      'creator': session.creatorId,
      'participants': session.participantIds,
      'permissions': session.permissions.index,
      'created_at': session.createdAt.toIso8601String(),
      'status': SessionStatus.active.index,
    };
    
    await _distributedEngine.syncData(
      groupId: session.id,
      key: 'session_info',
      value: syncData,
      syncMode: DistributedSyncMode.broadcast,
    );
  }
  
  // 共享物品状态更新
  Future<void> updateItemState({
    required String sessionId,
    required ItemState newState,
    String? operatorId,
  }) async {
    final session = _activeSessions[sessionId];
    if (session == null) return;
    
    // 验证操作权限
    if (!_checkPermission(session, operatorId, Permission.write)) {
      throw PermissionDeniedException('没有权限更新状态');
    }
    
    // 更新本地状态
    session.currentState = newState;
    
    // 分布式同步
    await _distributedEngine.syncData(
      groupId: sessionId,
      key: 'item_state',
      value: {
        'state': newState.toJson(),
        'operator': operatorId ?? await _getCurrentUserId(),
        'timestamp': DateTime.now().millisecondsSinceEpoch,
        'session_id': sessionId,
      },
      syncMode: DistributedSyncMode.broadcast,
    );
    
    // 触发状态变更事件
    _notifyStateChange(sessionId, newState);
  }
  
  // 跨设备控制授权
  Future<DeviceControlGrant> grantDeviceControl({
    required String sessionId,
    required String deviceId,
    required String granteeId,
    required List<ControlPermission> permissions,
    required Duration duration,
  }) async {
    final grant = DeviceControlGrant(
      id: 'grant_${DateTime.now().millisecondsSinceEpoch}',
      sessionId: sessionId,
      deviceId: deviceId,
      granteeId: granteeId,
      permissions: permissions,
      grantedAt: DateTime.now(),
      expiresAt: DateTime.now().add(duration),
      grantorId: await _getCurrentUserId(),
    );
    
    // HarmonyOS设备控制授权
    if (_isHarmonyDevice(deviceId)) {
      await _harmonyDeviceControl.grantAccess(
        deviceId: deviceId,
        userId: granteeId,
        permissions: _mapToHarmonyPermissions(permissions),
        duration: duration,
        sessionId: sessionId,
      );
    }
    
    // 同步授权信息
    await _distributedEngine.syncData(
      groupId: sessionId,
      key: 'control_grants/${grant.id}',
      value: grant.toJson(),
      syncMode: DistributedSyncMode.selective,
      targetDevices: [deviceId, granteeId],
    );
    
    // 存储授权记录
    _storeGrantRecord(grant);
    
    return grant;
  }
  
  // 处理数据同步事件
  void _handleDataSyncEvent(DistributedSyncEvent event) {
    switch (event.type) {
      case DistributedEventType.dataChanged:
        _handleDataChanged(event);
        break;
      case DistributedEventType.deviceJoined:
        _handleDeviceJoined(event);
        break;
      case DistributedEventType.deviceLeft:
        _handleDeviceLeft(event);
        break;
      case DistributedEventType.conflictDetected:
        _handleConflictDetected(event);
        break;
    }
  }
  
  void _handleDataChanged(DistributedSyncEvent event) {
    final data = event.data;
    final sessionId = data['session_id'];
    
    if (sessionId == null) return;
    
    final session = _activeSessions[sessionId];
    if (session == null) return;
    
    // 根据数据类型处理
    final dataType = data['data_type'];
    switch (dataType) {
      case 'item_state':
        _processItemStateUpdate(session, data);
        break;
      case 'control_grant':
        _processControlGrantUpdate(session, data);
        break;
      case 'chat_message':
        _processChatMessage(session, data);
        break;
    }
  }
  
  // 冲突解决策略
  Future<void> _handleConflictDetected(DistributedSyncEvent event) async {
    final conflict = DataConflict.fromJson(event.data);
    
    // 根据冲突类型选择解决策略
    switch (conflict.type) {
      case ConflictType.concurrentModification:
        await _resolveConcurrentModification(conflict);
        break;
      case ConflictType.versionMismatch:
        await _resolveVersionMismatch(conflict);
        break;
      case ConflictType.permissionConflict:
        await _resolvePermissionConflict(conflict);
        break;
      case ConflictType.dataIntegrity:
        await _resolveDataIntegrityConflict(conflict);
        break;
    }
  }
  
  Future<void> _resolveConcurrentModification(DataConflict conflict) async {
    // 获取业务规则
    final rules = await _getBusinessRules(conflict.dataType);
    
    if (rules.prioritizeCreator) {
      // 创建者优先
      final creatorDecision = await _getCreatorDecision(conflict);
      await _applyDecision(conflict, creatorDecision);
    } else if (rules.requireConsensus) {
      // 需要共识
      await _initiateConsensusVote(conflict);
    } else {
      // 默认：时间戳最新者胜出
      await _distributedEngine.resolveConflict(
        conflictId: conflict.id,
        strategy: ConflictResolutionStrategy.lastWriteWins,
      );
    }
  }
  
  // 会话管理
  Future<void> closeSession(String sessionId, {String? reason}) async {
    final session = _activeSessions[sessionId];
    if (session == null) return;
    
    // 更新会话状态
    session.status = SessionStatus.closed;
    session.closedAt = DateTime.now();
    session.closeReason = reason;
    
    // 通知所有参与者
    await _distributedEngine.syncData(
      groupId: sessionId,
      key: 'session_closed',
      value: {
        'session_id': sessionId,
        'closed_at': session.closedAt!.toIso8601String(),
        'reason': reason,
        'closed_by': await _getCurrentUserId(),
      },
      syncMode: DistributedSyncMode.broadcast,
    );
    
    // 清理资源
    await _cleanupSessionResources(sessionId);
    
    // 从活跃会话中移除
    _activeSessions.remove(sessionId);
  }
}

4.3 原子化服务开发

// HarmonyOS原子化服务定义
import { ServiceCard, AtomicService, DistributedDataManager } from '@ohos/atomic-service'

@Entry
@Component
struct SharingAtomicService {
  @State serviceData: ServiceData = new ServiceData()
  @State availableActions: Array<ServiceAction> = []
  @State nearbyItems: Array<SharedItem> = []
  @State isLoading: boolean = true
  
  private serviceManager: AtomicServiceManager
  private distributedData: DistributedDataManager
  private locationService: LocationService
  
  aboutToAppear() {
    this._initializeService()
    this._loadInitialData()
    this._setupDataSync()
  }
  
  // 初始化服务
  private async _initializeService() {
    this.serviceManager = new AtomicServiceManager()
    this.distributedData = new DistributedDataManager()
    this.locationService = new LocationService()
    
    // 注册原子化服务
    await this.serviceManager.registerService({
      serviceName: $r('app.string.sharing_service_name'),
      serviceType: ServiceType.SHARING,
      description: $r('app.string.sharing_service_desc'),
      icon: $r('app.media.service_icon'),
      minApiLevel: 7,
      capabilities: [
        'item_discovery',
        'quick_share',
        'nearby_devices',
        'instant_booking',
        'harmony_distributed',
      ],
      requiredPermissions: [
        'ohos.permission.LOCATION',
        'ohos.permission.DISTRIBUTED_DATASYNC',
      ],
    })
    
    // 注册服务动作
    await this._registerServiceActions()
    
    // 创建服务卡片
    await this._createServiceCards()
  }
  
  // 注册服务动作
  private async _registerServiceActions() {
    this.availableActions = [
      {
        id: 'quick_share',
        title: $r('app.string.action_quick_share'),
        icon: 'share',
        description: $r('app.string.action_quick_share_desc'),
        handler: () => this._handleQuickShare(),
        shortcut: true,
        requires: ['item_selected'],
      },
      {
        id: 'find_nearby',
        title: $r('app.string.action_find_nearby'),
        icon: 'location',
        description: $r('app.string.action_find_nearby_desc'),
        handler: () => this._handleFindNearby(),
        requires: ['location_permission'],
      },
      {
        id: 'instant_book',
        title: $r('app.string.action_instant_book'),
        icon: 'calendar',
        description: $r('app.string.action_instant_book_desc'),
        handler: () => this._handleInstantBook(),
        requires: ['item_selected', 'user_authenticated'],
      },
      {
        id: 'sync_devices',
        title: $r('app.string.action_sync_devices'),
        icon: 'device',
        description: $r('app.string.action_sync_devices_desc'),
        handler: () => this._handleSyncDevices(),
        requires: ['harmony_device'],
      },
    ]
    
    // 注册到系统服务中心
    await this.serviceManager.registerActions(this.availableActions)
  }
  
  // 创建服务卡片
  private async _createServiceCards() {
    // 快速共享卡片
    const quickShareCard = await ServiceCard.create({
      cardId: 'sharing_quick_actions',
      cardType: CardType.SERVICE,
      layout: CardLayout.GRID,
      dimensions: { rows: 2, columns: 2 },
      updateInterval: 300, // 5分钟更新
      contentBuilder: (context) => this._buildQuickActionsCard(),
      actionHandler: (action) => this._handleCardAction(action),
      config: {
        backgroundColor: '#FFFFFF',
        borderRadius: 16,
        padding: 12,
      },
    })
    
    // 附近推荐卡片
    const nearbyCard = await ServiceCard.create({
      cardId: 'sharing_nearby_items',
      cardType: CardType.INFORMATION,
      layout: CardLayout.LIST,
      dimensions: { rows: 3, columns: 1 },
      updateInterval: 600, // 10分钟更新
      contentBuilder: (context) => this._buildNearbyItemsCard(),
      actionHandler: (action) => this._handleCardAction(action),
    })
    
    // 最近活动卡片
    const activityCard = await ServiceCard.create({
      cardId: 'sharing_recent_activity',
      cardType: CardType.STATISTICS,
      layout: CardLayout.STACK,
      dimensions: { rows: 2, columns: 1 },
      updateInterval: 900, // 15分钟更新
      contentBuilder: (context) => this._buildActivityCard(),
    })
  }
  
  // 构建快速操作卡片
  @Builder
  private _buildQuickActionsCard() {
    Grid() {
      ForEach(this.availableActions.filter(a => a.shortcut), 
        (action: ServiceAction) => {
        GridItem() {
          Column() {
            Image($r(`app.media.ic_${action.icon}`))
              .width(32)
              .height(32)
              .margin({ bottom: 8 })
            Text(action.title)
              .fontSize(10)
              .fontColor(Color.Black)
              .maxLines(1)
              .textOverflow({ overflow: TextOverflow.Ellipsis })
          }
          .width('100%')
          .height('100%')
          .justifyContent(FlexAlign.Center)
          .onClick(() => action.handler())
        }
      })
    }
    .columnsTemplate('1fr 1fr')
    .rowsTemplate('1fr 1fr')
    .height('100%')
  }
  
  // 构建附近物品卡片
  @Builder
  private _buildNearbyItemsCard() {
    Column() {
      // 标题
      Row() {
        Text($r('app.string.nearby_items'))
          .fontSize(14)
          .fontWeight(FontWeight.Bold)
        Blank()
        Text(`${this.nearbyItems.length}项`)
          .fontSize(12)
          .fontColor(Color.Gray)
      }
      .width('100%')
      .margin({ bottom: 12 })
      
      // 物品列表
      if (this.nearbyItems.length > 0) {
        ForEach(this.nearbyItems.slice(0, 3), (item: SharedItem) => {
          Row() {
            // 图片
            if (item.imageUrls.length > 0) {
              Image(item.imageUrls[0])
                .width(40)
                .height(40)
                .borderRadius(8)
                .margin({ right: 12 })
            }
            
            // 信息
            Column({ space: 4 }) {
              Text(item.title)
                .fontSize(12)
                .fontColor(Color.Black)
                .maxLines(1)
              Text(`${item.pricePerDay}元/天`)
                .fontSize(10)
                .fontColor(Color.Blue)
            }
            .layoutWeight(1)
            
            // 距离
            if (item.distance) {
              Text(`${item.distance.toFixed(1)}km`)
                .fontSize(10)
                .fontColor(Color.Gray)
            }
          }
          .width('100%')
          .padding(8)
          .backgroundColor(Color.White)
          .borderRadius(8)
          .margin({ bottom: 8 })
          .onClick(() => this._onItemClicked(item))
        })
      } else {
        Text($r('app.string.no_nearby_items'))
          .fontSize(12)
          .fontColor(Color.Gray)
          .textAlign(TextAlign.Center)
          .width('100%')
          .margin({ top: 20 })
      }
    }
    .width('100%')
    .padding(12)
  }
  
  // 服务动作处理
  private async _handleQuickShare() {
    // 获取当前上下文
    const context = await this.serviceManager.getCurrentContext()
    
    // 识别可共享内容
    const shareableItems = await this._identifyShareableItems(context)
    
    if (shareableItems.length === 0) {
      // 提示用户
      await this.serviceManager.showToast(
        $r('app.string.no_shareable_items')
      )
      return
    }
    
    // 显示快速共享界面
    await this._showQuickShareUI(shareableItems)
  }
  
  private async _handleFindNearby() {
    // 请求位置权限
    const hasPermission = await this.locationService.requestPermission()
    if (!hasPermission) {
      await this.serviceManager.showDialog({
        title: $r('app.string.permission_required'),
        message: $r('app.string.location_permission_desc'),
        buttons: [
          {
            text: $r('app.string.settings'),
            action: () => this._openAppSettings()
          }
        ]
      })
      return
    }
    
    this.isLoading = true
    
    try {
      // 获取当前位置
      const location = await this.locationService.getCurrentLocation()
      
      // 查询附近物品
      this.nearbyItems = await this.serviceData.findNearbyItems({
        latitude: location.latitude,
        longitude: location.longitude,
        radius: 5, // 5公里
        categories: await this._getPreferredCategories(),
        maxResults: 20,
        filterHarmonyCompatible: true,
      })
      
      // 更新服务卡片
      await this._updateServiceCards()
      
    } catch (error) {
      await this.serviceManager.showToast(
        $r('app.string.location_error')
      )
    } finally {
      this.isLoading = false
    }
  }
  
  // 分布式数据同步
  private async _setupDataSync() {
    // 监听分布式数据变化
    this.distributedData.onDataChanged((event) => {
      this._handleDistributedDataChange(event)
    })
    
    // 同步用户偏好
    await this._syncUserPreferences()
    
    // 同步共享会话
    await this._syncSharingSessions()
  }
  
  private _handleDistributedDataChange(event: DataChangeEvent) {
    switch (event.dataType) {
      case 'user_profile':
        this._updateUserProfile(event.data)
        break
      case 'shared_items':
        this._updateSharedItems(event.data)
        break
      case 'transactions':
        this._updateTransactions(event.data)
        break
      case 'harmony_devices':
        this._updateHarmonyDevices(event.data)
        break
    }
  }
  
  // 服务主界面
  build() {
    Column() {
      // 服务头部
      this._buildServiceHeader()
      
      // 内容区域
      Scroll() {
        Column() {
          if (this.isLoading) {
            Loading()
              .width(40)
              .height(40)
              .margin({ top: 100 })
          } else {
            // 快速操作区
            this._buildQuickActionsArea()
            
            // 附近推荐
            if (this.nearbyItems.length > 0) {
              this._buildNearbyRecommendations()
            }
            
            // 最近活动
            this._buildRecentActivity()
            
            // HarmonyOS设备区
            if (this._hasHarmonyDevices()) {
              this._buildHarmonyDevicesArea()
            }
          }
        }
        .padding(20)
      }
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }
  
  @Builder
  private _buildServiceHeader() {
    Column() {
      Row() {
        Image($r('app.media.app_logo'))
          .width(40)
          .height(40)
          .margin({ right: 12 })
        
        Column({ space: 4 }) {
          Text($r('app.string.sharing_service_name'))
            .fontSize(18)
            .fontWeight(FontWeight.Bold)
          Text($r('app.string.sharing_service_tagline'))
            .fontSize(12)
            .fontColor(Color.Gray)
        }
        .layoutWeight(1)
        
        // 设置按钮
        Image($r('app.media.ic_settings'))
          .width(24)
          .height(24)
          .onClick(() => this._openSettings())
      }
      
      Divider()
        .strokeWidth(1)
        .color('#E0E0E0')
        .margin({ top: 16, bottom: 16 })
    }
    .padding({ top: 40, left: 20, right: 20, bottom: 0 })
    .backgroundColor(Color.White)
  }
}

第五章：一体化部署方案

5.1 多平台构建配置

# pubspec.yaml - 多平台配置
name: sharing_community
description: 共享社区跨平台应用
version: 1.0.0+1
publish_to: 'none'

environment:
  sdk: ">=2.19.0 <3.0.0"
  flutter: ">=3.7.0"

dependencies:
  flutter:
    sdk: flutter
  
  # 核心框架
  flutter_bloc: ^8.1.3
  provider: ^6.0.5
  
  # 网络与数据
  dio: ^5.3.3
  retrofit: ^4.0.1
  hive: ^2.2.3
  shared_preferences: ^2.2.2
  
  # UI组件
  flutter_screenutil: ^5.9.0
  cached_network_image: ^3.3.0
  pull_to_refresh: ^2.0.0
  
  # 地图与位置
  google_maps_flutter: ^2.2.6
  geolocator: ^9.0.2
  geocoding: ^2.0.5
  
  # 支付与安全
  in_app_purchase: ^4.0.2
  local_auth: ^2.1.6
  encrypt: ^5.0.1
  
  # HarmonyOS集成
  harmonyos_flutter_plugin:
    git:
      url: https://gitee.com/harmonyos/flutter-harmony-plugin.git
      ref: v1.2.0
  flutter_harmony_bridge: ^0.9.1
  
  # 工具类
  intl: ^0.18.1
  url_launcher: ^6.1.10
  image_picker: ^0.8.7+4
  permission_handler: ^10.3.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  hive_generator: ^1.1.3
  retrofit_generator: ^4.0.1
  build_runner: ^2.3.3
  flutter_lints: ^2.0.1

flutter:
  uses-material-design: true
  
  # 多平台资源配置
  assets:
    - assets/images/
    - assets/icons/
    - assets/fonts/
    - assets/translations/
    - assets/lottie/
  
  # HarmonyOS特有资源
  harmonyos:
    enabled: true
    assets:
      - harmony_assets/
      - harmony_icons/
    permissions:
      - ohos.permission.INTERNET
      - ohos.permission.LOCATION
      - ohos.permission.DISTRIBUTED_DATASYNC
      - ohos.permission.DISTRIBUTED_DEVICE_STATE_CHANGE
      - ohos.permission.CAMERA
      - ohos.permission.MICROPHONE
    capabilities:
      - distributed.screen
      - distributed.audio
      - distributed.data
      - atomic.service
  
  # 字体配置
  fonts:
    - family: HarmonySans
      fonts:
        - asset: assets/fonts/HarmonySans-Regular.ttf
        - asset: assets/fonts/HarmonySans-Medium.ttf
          weight: 500
        - asset: assets/fonts/HarmonySans-Bold.ttf
          weight: 700
  
  # 构建配置
  build:
    android:
      enable_shared_preferences: true
      enable_google_maps: true
      enable_splash_screen: true
    ios:
      enable_background_fetch: true
      enable_push_notifications: true
    harmonyos:
      min_api_level: 7
      target_api_level: 9
      enable_distributed: true
      enable_atomic_service: true
      enable_service_card: true
  
  # 多环境配置
  flavors:
    development:
      name: "共享社区(开发)"
      applicationIdSuffix: ".dev"
    staging:
      name: "共享社区(测试)"
      applicationIdSuffix: ".staging"
    production:
      name: "共享社区"

5.2 自动化构建脚本

#!/bin/bash
# build_all_platforms.sh - 一体化构建脚本

set -e  # 遇到错误退出

# 配置参数
APP_NAME="共享社区"
VERSION=${1:-"1.0.0"}
BUILD_NUMBER=${2:-"1"}
ENVIRONMENT=${3:-"production"}
PLATFORMS=${4:-"android,ios,harmony,web"}

# 目录配置
BUILD_DIR="build_output"
LOG_DIR="logs"
REPORT_DIR="reports"
CONFIG_DIR="config"

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 日志函数
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 创建目录
create_directories() {
    log_info "创建构建目录..."
    mkdir -p $BUILD_DIR $LOG_DIR $REPORT_DIR $CONFIG_DIR
}

# 环境检查
check_environment() {
    log_info "检查构建环境..."
    
    # 检查Flutter
    if ! command -v flutter &> /dev/null; then
        log_error "Flutter未安装"
        exit 1
    fi
    
    # 检查Flutter版本
    FLUTTER_VERSION=$(flutter --version | grep "Flutter" | awk '{print $2}')
    log_info "Flutter版本: $FLUTTER_VERSION"
    
    # 检查依赖
    log_info "安装依赖..."
    flutter pub get
    
    if [ $? -ne 0 ]; then
        log_error "依赖安装失败"
        exit 1
    fi
    
    # 生成代码
    log_info "生成代码..."
    flutter gen-l10n
    flutter pub run build_runner build --delete-conflicting-outputs
    
    # 检查HarmonyOS环境
    if [[ "$PLATFORMS" == *"harmony"* ]]; then
        if [ ! -d "harmony" ]; then
            log_warning "HarmonyOS项目目录不存在，跳过HarmonyOS构建"
            PLATFORMS=${PLATFORMS/harmony/}
        elif [ ! -f "harmony/hvigorfile.js" ]; then
            log_warning "HarmonyOS项目配置不完整，跳过HarmonyOS构建"
            PLATFORMS=${PLATFORMS/harmony/}
        fi
    fi
    
    log_success "环境检查通过"
}

# Android构建
build_android() {
    log_info "开始Android构建..."
    
    local BUILD_VARIANT="release"
    local APP_SUFFIX=""
    
    case $ENVIRONMENT in
        "development")
            BUILD_VARIANT="debug"
            APP_SUFFIX=".dev"
            ;;
        "staging")
            BUILD_VARIANT="staging"
            APP_SUFFIX=".staging"
            ;;
    esac
    
    # 执行构建
    flutter build apk \
        --$BUILD_VARIANT \
        --target-platform android-arm64 \
        --build-name=$VERSION \
        --build-number=$BUILD_NUMBER \
        --dart-define=ENVIRONMENT=$ENVIRONMENT \
        --dart-define=PLATFORM=ANDROID \
        --dart-define=APP_SUFFIX=$APP_SUFFIX \
        --split-debug-info=$BUILD_DIR/debug_info/android \
        --obfuscate \
        --tree-shake-icons \
        --no-shrink \
        2>&1 | tee $LOG_DIR/android_build.log
    
    local BUILD_STATUS=${PIPESTATUS[0]}
    
    if [ $BUILD_STATUS -eq 0 ]; then
        # 复制APK文件
        local APK_FILE="build/app/outputs/flutter-apk/app-$BUILD_VARIANT.apk"
        local OUTPUT_FILE="$BUILD_DIR/${APP_NAME}_android_${ENVIRONMENT}_v${VERSION}.apk"
        
        cp $APK_FILE $OUTPUT_FILE
        
        # 生成映射文件
        if [ -f "build/app/outputs/mapping/$BUILD_VARIANT/mapping.txt" ]; then
            cp build/app/outputs/mapping/$BUILD_VARIANT/mapping.txt \
               $BUILD_DIR/android_mapping_${ENVIRONMENT}.txt
        fi
        
        # 计算文件大小
        local FILE_SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE")
        local FILE_SIZE_MB=$(echo "scale=2; $FILE_SIZE / 1024 / 1024" | bc)
        
        log_success "Android构建成功: $OUTPUT_FILE (${FILE_SIZE_MB}MB)"
        return 0
    else
        log_error "Android构建失败"
        return 1
    fi
}

# iOS构建
build_ios() {
    log_info "开始iOS构建..."
    
    # 检查iOS环境
    if ! command -v xcodebuild &> /dev/null; then
        log_warning "Xcode未安装，跳过iOS构建"
        return 0
    fi
    
    local CONFIGURATION="Release"
    local SCHEME="SharingCommunity"
    
    case $ENVIRONMENT in
        "development")
            CONFIGURATION="Debug"
            ;;
        "staging")
            CONFIGURATION="Staging"
            ;;
    esac
    
    # 清理项目
    xcodebuild clean \
        -workspace ios/Runner.xcworkspace \
        -scheme $SCHEME \
        -configuration $CONFIGURATION \
        2>&1 | tee $LOG_DIR/ios_clean.log
    
    # 归档
    xcodebuild archive \
        -workspace ios/Runner.xcworkspace \
        -scheme $SCHEME \
        -configuration $CONFIGURATION \
        -archivePath $BUILD_DIR/ios/Runner.xcarchive \
        -destination generic/platform=iOS \
        CODE_SIGNING_ALLOWED=NO \
        2>&1 | tee $LOG_DIR/ios_archive.log
    
    # 导出IPA
    xcodebuild -exportArchive \
        -archivePath $BUILD_DIR/ios/Runner.xcarchive \
        -exportOptionsPlist ios/ExportOptions.plist \
        -exportPath $BUILD_DIR/ios \
        2>&1 | tee $LOG_DIR/ios_export.log
    
    if [ -f "$BUILD_DIR/ios/$SCHEME.ipa" ]; then
        local OUTPUT_FILE="$BUILD_DIR/${APP_NAME}_ios_${ENVIRONMENT}_v${VERSION}.ipa"
        cp "$BUILD_DIR/ios/$SCHEME.ipa" $OUTPUT_FILE
        
        # 计算文件大小
        local FILE_SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE")
        local FILE_SIZE_MB=$(echo "scale=2; $FILE_SIZE / 1024 / 1024" | bc)
        
        log_success "iOS构建成功: $OUTPUT_FILE (${FILE_SIZE_MB}MB)"
        return 0
    else
        log_error "iOS构建失败"
        return 1
    fi
}

# HarmonyOS构建
build_harmony() {
    log_info "开始HarmonyOS构建..."
    
    cd harmony
    
    # 清理
    hvigorw clean 2>&1 | tee ../$LOG_DIR/harmony_clean.log
    
    # 构建HAP
    local BUILD_MODE="release"
    case $ENVIRONMENT in
        "development")
            BUILD_MODE="debug"
            ;;
        "staging")
            BUILD_MODE="debug"
            ;;
    esac
    
    hvigorw assembleHap --mode $BUILD_MODE --env $ENVIRONMENT \
        2>&1 | tee ../$LOG_DIR/harmony_build.log
    
    local BUILD_STATUS=${PIPESTATUS[0]}
    
    if [ $BUILD_STATUS -eq 0 ]; then
        # 查找HAP文件
        local HAP_FILE=$(find entry/build -name "*.hap" | head -1)
        
        if [ -n "$HAP_FILE" ]; then
            local OUTPUT_FILE="../$BUILD_DIR/${APP_NAME}_harmony_${ENVIRONMENT}_v${VERSION}.hap"
            cp $HAP_FILE $OUTPUT_FILE
            
            # 复制调试信息
            if [ -d "entry/build/intermediates/symbols" ]; then
                cp entry/build/intermediates/symbols/*.txt \
                   ../$BUILD_DIR/harmony_symbols_${ENVIRONMENT}.txt 2>/dev/null || true
            fi
            
            # 计算文件大小
            local FILE_SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE")
            local FILE_SIZE_MB=$(echo "scale=2; $FILE_SIZE / 1024 / 1024" | bc)
            
            log_success "HarmonyOS构建成功: $OUTPUT_FILE (${FILE_SIZE_MB}MB)"
            cd ..
            return 0
        fi
    fi
    
    log_error "HarmonyOS构建失败"
    cd ..
    return 1
}

# Web构建
build_web() {
    log_info "开始Web构建..."
    
    # 执行构建
    flutter build web \
        --release \
        --web-renderer canvaskit \
        --base-href /sharing-community/ \
        --dart-define=ENVIRONMENT=$ENVIRONMENT \
        --dart-define=PLATFORM=WEB \
        --pwa-strategy offline-first \
        --source-maps \
        --no-tree-shake-icons \
        2>&1 | tee $LOG_DIR/web_build.log
    
    if [ $? -eq 0 ]; then
        # 压缩并打包
        cd build/web
        tar -czf ../../$BUILD_DIR/${APP_NAME}_web_${ENVIRONMENT}_v${VERSION}.tar.gz .
        cd ../..
        
        # 生成部署清单
        _generate_web_manifest
        
        # 计算文件大小
        local OUTPUT_FILE="$BUILD_DIR/${APP_NAME}_web_${ENVIRONMENT}_v${VERSION}.tar.gz"
        local FILE_SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE")
        local FILE_SIZE_MB=$(echo "scale=2; $FILE_SIZE / 1024 / 1024" | bc)
        
        log_success "Web构建成功: $OUTPUT_FILE (${FILE_SIZE_MB}MB)"
        return 0
    else
        log_error "Web构建失败"
        return 1
    fi
}

_generate_web_manifest() {
    cat > $BUILD_DIR/web_manifest_${ENVIRONMENT}.json << EOF
{
  "app_name": "$APP_NAME",
  "version": "$VERSION",
  "build_number": "$BUILD_NUMBER",
  "environment": "$ENVIRONMENT",
  "build_time": "$(date -Iseconds)",
  "platform": "web",
  "files": {
    "main": "main.dart.js",
    "styles": "styles.css",
    "icons": [
      "icons/Icon-192.png",
      "icons/Icon-512.png"
    ],
    "assets": "assets/"
  },
  "deployment": {
    "cdn_url": "https://cdn.sharing-community.com/v$VERSION/",
    "api_endpoint": "https://api.$ENVIRONMENT.sharing-community.com",
    "websocket_endpoint": "wss://ws.$ENVIRONMENT.sharing-community.com",
    "cdn_enabled": true,
    "compression": "gzip",
    "cache_control": "public, max-age=31536000"
  }
}
EOF
}

# 生成构建报告
generate_build_report() {
    log_info "生成构建报告..."
    
    local REPORT_FILE="$REPORT_DIR/build_report_${ENVIRONMENT}_v${VERSION}.md"
    
    cat > $REPORT_FILE << EOF
# 构建报告 - $APP_NAME

## 基本信息
- **应用名称**: $APP_NAME
- **版本**: $VERSION (Build $BUILD_NUMBER)
- **环境**: $ENVIRONMENT
- **构建时间**: $(date)
- **构建平台**: $PLATFORMS
- **Flutter版本**: $FLUTTER_VERSION

## 构建结果
| 平台 | 状态 | 文件大小 | 输出文件 |
|------|------|---------|---------|
EOF
    
    # 添加各平台信息
    for platform in android ios harmony web; do
        if [[ "$PLATFORMS" == *"$platform"* ]]; then
            local OUTPUT_FILE="$BUILD_DIR/${APP_NAME}_${platform}_${ENVIRONMENT}_v${VERSION}"
            if [ "$platform" = "web" ]; then
                OUTPUT_FILE="$OUTPUT_FILE.tar.gz"
            elif [ "$platform" = "harmony" ]; then
                OUTPUT_FILE="$OUTPUT_FILE.hap"
            elif [ "$platform" = "android" ]; then
                OUTPUT_FILE="$OUTPUT_FILE.apk"
            elif [ "$platform" = "ios" ]; then
                OUTPUT_FILE="$OUTPUT_FILE.ipa"
            fi
            
            if [ -f "$OUTPUT_FILE" ]; then
                local FILE_SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE")
                local FILE_SIZE_MB=$(echo "scale=2; $FILE_SIZE / 1024 / 1024" | bc)
                echo "| $platform | ✅ 成功 | ${FILE_SIZE_MB}MB | $(basename $OUTPUT_FILE) |" >> $REPORT_FILE
            else
                echo "| $platform | ❌ 失败 | - | - |" >> $REPORT_FILE
            fi
        fi
    done
    
    cat >> $REPORT_FILE << EOF

## 构建日志
- Android: $LOG_DIR/android_build.log
- iOS: $LOG_DIR/ios_build.log
- HarmonyOS: $LOG_DIR/harmony_build.log
- Web: $LOG_DIR/web_build.log

## 质量指标
$(if [ -f "$BUILD_DIR/android_mapping_${ENVIRONMENT}.txt" ]; then echo "- Android混淆映射文件已生成"; fi)
$(if [ -f "$BUILD_DIR/harmony_symbols_${ENVIRONMENT}.txt" ]; then echo "- HarmonyOS符号文件已生成"; fi)
$(if [ -f "$BUILD_DIR/web_manifest_${ENVIRONMENT}.json" ]; then echo "- Web部署清单已生成"; fi)

## 下一步
1. 测试构建产物
2. 部署到对应平台
3. 发布更新通知
4. 监控应用性能

---
*自动生成于 $(date)*
EOF
    
    log_success "构建报告已生成: $REPORT_FILE"
}

# 主构建流程
main() {
    log_info "🚀 开始构建: $APP_NAME v$VERSION ($ENVIRONMENT)"
    
    create_directories
    check_environment
    
    # 解析平台参数
    IFS=',' read -ra PLATFORM_ARRAY <<< "$PLATFORMS"
    
    local SUCCESS_COUNT=0
    local TOTAL_COUNT=${#PLATFORM_ARRAY[@]}
    
    for platform in "${PLATFORM_ARRAY[@]}"; do
        case $platform in
            "android")
                build_android && ((SUCCESS_COUNT++))
                ;;
            "ios")
                build_ios && ((SUCCESS_COUNT++))
                ;;
            "harmony")
                build_harmony && ((SUCCESS_COUNT++))
                ;;
            "web")
                build_web && ((SUCCESS_COUNT++))
                ;;
        esac
    done
    
    # 生成构建报告
    generate_build_report
    
    if [ $SUCCESS_COUNT -eq $TOTAL_COUNT ]; then
        log_success "🎉 所有平台构建完成！"
        log_info "📁 输出目录: $BUILD_DIR"
        ls -lh $BUILD_DIR/
    else
        log_warning "⚠️ $SUCCESS_COUNT/$TOTAL_COUNT 个平台构建成功"
        log_info "请检查日志文件: $LOG_DIR/"
        exit 1
    fi
}

# 执行主函数
main "$@"

5.3 持续集成/持续部署配置

# .github/workflows/build-and-deploy.yml
name: Build and Deploy

on:
  push:
    branches: [ main, develop ]
    tags:
      - 'v*'
  pull_request:
    branches: [ main ]
  workflow_dispatch:
    inputs:
      environment:
        description: '部署环境'
        required: true
        default: 'staging'
        type: choice
        options:
          - development
          - staging
          - production
      platforms:
        description: '构建平台'
        required: true
        default: 'android,harmony,web'
        type: choice
        options:
          - android
          - ios
          - harmony
          - web
          - all

jobs:
  analyze:
    name: Analyze
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.7.0'
      - run: flutter analyze
      - run: flutter test --coverage
      - uses: codecov/codecov-action@v3
        with:
          file: ./coverage/lcov.info

  build-android:
    name: Build Android
    runs-on: ubuntu-latest
    needs: analyze
    if: contains(github.event.inputs.platforms, 'android') || contains(github.event.inputs.platforms, 'all') || github.event.inputs.platforms == null
    steps:
      - uses: actions/checkout@v3
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.7.0'
      - run: flutter pub get
      - name: Build APK
        run: |
          chmod +x ./scripts/build_all_platforms.sh
          ./scripts/build_all_platforms.sh \
            ${{ github.ref_name }} \
            ${{ github.run_number }} \
            ${{ github.event.inputs.environment || 'staging' }} \
            android
      - uses: actions/upload-artifact@v3
        with:
          name: android-apk
          path: build_output/*.apk

  build-harmony:
    name: Build HarmonyOS
    runs-on: ubuntu-latest
    needs: analyze
    if: contains(github.event.inputs.platforms, 'harmony') || contains(github.event.inputs.platforms, 'all') || github.event.inputs.platforms == null
    steps:
      - uses: actions/checkout@v3
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.7.0'
      - name: Setup HarmonyOS Environment
        run: |
          # 安装HarmonyOS开发工具
          wget https://repo.huaweicloud.com/harmonyos/compiler/openharmony-2.0-canary/linux/openharmony-2.0-canary.tar.gz
          tar -xzf openharmony-2.0-canary.tar.gz
          export PATH=$PWD/openharmony-2.0-canary/bin:$PATH
      - run: flutter pub get
      - name: Build HAP
        run: |
          chmod +x ./scripts/build_all_platforms.sh
          ./scripts/build_all_platforms.sh \
            ${{ github.ref_name }} \
            ${{ github.run_number }} \
            ${{ github.event.inputs.environment || 'staging' }} \
            harmony
      - uses: actions/upload-artifact@v3
        with:
          name: harmony-hap
          path: build_output/*.hap

  build-web:
    name: Build Web
    runs-on: ubuntu-latest
    needs: analyze
    if: contains(github.event.inputs.platforms, 'web') || contains(github.event.inputs.platforms, 'all') || github.event.inputs.platforms == null
    steps:
      - uses: actions/checkout@v3
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.7.0'
      - run: flutter pub get
      - name: Build Web
        run: |
          chmod +x ./scripts/build_all_platforms.sh
          ./scripts/build_all_platforms.sh \
            ${{ github.ref_name }} \
            ${{ github.run_number }} \
            ${{ github.event.inputs.environment || 'staging' }} \
            web
      - uses: actions/upload-artifact@v3
        with:
          name: web-build
          path: build_output/*.tar.gz

  deploy:
    name: Deploy
    runs-on: ubuntu-latest
    needs: [build-android, build-harmony, build-web]
    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v'))
    steps:
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Deploy to AppGallery
        if: needs.build-harmony.result == 'success'
        env:
          HUAWEI_APP_ID: ${{ secrets.HUAWEI_APP_ID }}
          HUAWEI_CLIENT_ID: ${{ secrets.HUAWEI_CLIENT_ID }}
          HUAWEI_CLIENT_SECRET: ${{ secrets.HUAWEI_CLIENT_SECRET }}
        run: |
          # 上传到华为应用市场
          python scripts/deploy_to_appgallery.py \
            --app-id $HUAWEI_APP_ID \
            --client-id $HUAWEI_CLIENT_ID \
            --client-secret $HUAWEI_CLIENT_SECRET \
            --hap-file artifacts/harmony-hap/*.hap \
            --environment ${{ github.event.inputs.environment || 'production' }}
      - name: Deploy to CDN
        if: needs.build-web.result == 'success'
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          AWS_REGION: ${{ secrets.AWS_REGION }}
        run: |
          # 解压Web构建文件
          tar -xzf artifacts/web-build/*.tar.gz -C /tmp/web-build
          
          # 上传到S3/CDN
          aws s3 sync /tmp/web-build s3://sharing-community-${{ github.event.inputs.environment || 'production' }}/ \
            --acl public-read \
            --cache-control "public, max-age=31536000"
          
          # 刷新CDN缓存
          aws cloudfront create-invalidation \
            --distribution-id ${{ secrets.CLOUDFRONT_DISTRIBUTION_ID }} \
            --paths "/*"
      - name: Send Notification
        run: |
          # 发送构建通知
          python scripts/send_notification.py \
            --version ${{ github.ref_name }} \
            --environment ${{ github.event.inputs.environment || 'production' }} \
            --success true \
            --build-url https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}

第六章：质量保障与性能优化

6.1 性能监控与优化

// 性能监控管理器
class PerformanceMonitor {
  static final PerformanceMonitor _instance = PerformanceMonitor._internal();
  
  factory PerformanceMonitor() => _instance;
  
  final Map<String, PerformanceMetric> _metrics = {};
  final List<PerformanceIssue> _issues = [];
  Timer? _monitoringTimer;
  
  PerformanceMonitor._internal() {
    _startMonitoring();
  }
  
  void _startMonitoring() {
    // 监控帧率
    WidgetsBinding.instance!.addTimingsCallback((List<FrameTiming> timings) {
      _recordFrameTimings(timings);
    });
    
    // 定期检查性能
    _monitoringTimer = Timer.periodic(Duration(seconds: 5), (_) {
      _checkPerformance();
    });
    
    // 监听内存警告
    SystemChannels.lifecycle.setMessageHandler((msg) {
      if (msg == AppLifecycleState.paused.toString()) {
        _onAppBackgrounded();
      } else if (msg == AppLifecycleState.resumed.toString()) {
        _onAppForegrounded();
      }
      return Future.value();
    });
  }
  
  void _recordFrameTimings(List<FrameTiming> timings) {
    for (final timing in timings) {
      final frameTime = timing.totalSpan.inMilliseconds;
      
      // 记录帧时间
      _metrics['frame_time'] = PerformanceMetric(
        name: 'frame_time',
        value: frameTime,
        timestamp: DateTime.now(),
      );
      
      // 检测掉帧
      if (frameTime > 16) { // 超过60fps的阈值
        _recordIssue(PerformanceIssue(
          type: IssueType.slow_frame,
          severity: frameTime > 32 ? Severity.high : Severity.medium,
          description: '帧时间过长: ${frameTime}ms',
          timestamp: DateTime.now(),
          context: {
            'frame_time': frameTime,
            'phase_times': {
              'build': timing.buildDuration.inMilliseconds,
              'raster': timing.rasterDuration.inMilliseconds,
            },
          },
        ));
      }
    }
  }
  
  void _checkPerformance() async {
    // 检查内存使用
    if (Platform.isAndroid || Platform.isIOS) {
      final memoryUsage = await _getMemoryUsage();
      _metrics['memory_usage'] = PerformanceMetric(
        name: 'memory_usage',
        value: memoryUsage,
        timestamp: DateTime.now(),
      );
      
      if (memoryUsage > 500) { // 超过500MB
        _recordIssue(PerformanceIssue(
          type: IssueType.high_memory,
          severity: Severity.high,
          description: '内存使用过高: ${memoryUsage}MB',
          timestamp: DateTime.now(),
        ));
        
        // 尝试释放内存
        _tryFreeMemory();
      }
    }
    
    // HarmonyOS设备特有检查
    if (Platform.isHarmonyOS) {
      await _checkHarmonyPerformance();
    }
  }
  
  Future<void> _checkHarmonyPerformance() async {
    try {
      // 获取HarmonyOS设备性能信息
      final performanceInfo = await MethodChannel('com.sharing.community/performance')
          .invokeMethod<Map>('getPerformanceInfo');
      
      if (performanceInfo != null) {
        final cpuUsage = performanceInfo['cpu_usage'] as double;
        final gpuUsage = performanceInfo['gpu_usage'] as double;
        final thermalState = performanceInfo['thermal_state'] as int;
        
        _metrics['harmony_cpu'] = PerformanceMetric(
          name: 'harmony_cpu',
          value: cpuUsage,
          timestamp: DateTime.now(),
        );
        
        _metrics['harmony_gpu'] = PerformanceMetric(
          name: 'harmony_gpu',
          value: gpuUsage,
          timestamp: DateTime.now(),
        );
        
        // 根据设备状态调整性能
        if (thermalState > 2) { // 设备过热
          _adjustPerformanceForThermal();
        }
        
        if (cpuUsage > 80 || gpuUsage > 80) {
          _reduceRenderingQuality();
        }
      }
    } catch (e) {
      print('获取HarmonyOS性能信息失败: $e');
    }
  }
  
  void _adjustPerformanceForThermal() {
    // 降低渲染质量
    _reduceRenderingQuality();
    
    // 减少后台任务
    _reduceBackgroundTasks();
    
    // 提示用户
    _showThermalWarning();
  }
  
  void _reduceRenderingQuality() {
    // 降低图片质量
    PaintingBinding.instance!.imageCache.maximumSize = 50;
    PaintingBinding.instance!.imageCache.maximumSizeBytes = 50 * 1024 * 1024;
    
    // 禁用复杂动画
    AnimationController.debugDisposeAnimations = false;
    
    // 简化阴影和效果
    _simplifyVisualEffects();
  }
  
  // 性能优化建议
  Map<String, dynamic> getOptimizationSuggestions() {
    final suggestions = <String, dynamic>{};
    
    // 分析性能数据
    final avgFrameTime = _calculateAverageFrameTime();
    final peakMemory = _getPeakMemoryUsage();
    
    if (avgFrameTime > 16) {
      suggestions['frame_time'] = {
        'issue': '平均帧时间过长',
        'suggestion': '优化Widget重建，使用const构造函数',
        'priority': 'high',
        'actions': [
          '使用const Widget',
          '优化setState调用',
          '使用RepaintBoundary',
        ],
      };
    }
    
    if (peakMemory > 400) {
      suggestions['memory'] = {
        'issue': '内存使用过高',
        'suggestion': '减少图片缓存，及时释放资源',
        'priority': 'high',
        'actions': [
          '使用cached_network_image',
          '及时释放Controller',
          '优化列表项复用',
        ],
      };
    }
    
    // HarmonyOS特有建议
    if (Platform.isHarmonyOS) {
      final harmonyMetrics = _metrics.values
          .where((m) => m.name.startsWith('harmony_'))
          .toList();
      
      if (harmonyMetrics.isNotEmpty) {
        suggestions['harmony'] = {
          'issue': 'HarmonyOS设备性能优化',
          'suggestion': '启用分布式渲染，使用原生组件',
          'priority': 'medium',
          'actions': [
            '使用ArkUI原生组件',
            '启用分布式数据同步',
            '优化跨设备通信',
          ],
        };
      }
    }
    
    return suggestions;
  }
}

6.2 自动化测试策略

// 集成测试套件
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:sharing_community/main.dart';

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  group('共享社区端到端测试', () {
    testWidgets('用户完整流程测试', (WidgetTester tester) async {
      // 启动应用
      await tester.pumpWidget(SharingCommunityApp());
      await tester.pumpAndSettle();
      
      // 1. 注册流程
      expect(find.text('共享社区'), findsOneWidget);
      await tester.tap(find.text('注册'));
      await tester.pumpAndSettle();
      
      // 填写注册信息
      await tester.enterText(find.byKey(Key('phone_field')), '13800138000');
      await tester.enterText(find.byKey(Key('code_field')), '123456');
      await tester.tap(find.text('获取验证码'));
      await tester.pump(Duration(seconds: 1));
      
      // 2. 主页面测试
      await tester.tap(find.text('跳过引导'));
      await tester.pumpAndSettle();
      
      expect(find.text('发现'), findsOneWidget);
      expect(find.text('发布'), findsOneWidget);
      expect(find.text('消息'), findsOneWidget);
      expect(find.text('我的'), findsOneWidget);
      
      // 3. 发布物品测试
      await tester.tap(find.text('发布'));
      await tester.pumpAndSettle();
      
      await tester.enterText(find.byKey(Key('title_field')), '测试物品');
      await tester.enterText(find.byKey(Key('price_field')), '50');
      await tester.tap(find.byKey(Key('category_dropdown')));
      await tester.pumpAndSettle();
      await tester.tap(find.text('电子产品'));
      await tester.pumpAndSettle();
      
      // HarmonyOS兼容性选项
      if (Platform.isHarmonyOS) {
        await tester.tap(find.byKey(Key('harmony_compatible_switch')));
        await tester.pump();
      }
      
      await tester.tap(find.text('发布'));
      await tester.pumpAndSettle();
      
      expect(find.text('发布成功'), findsOneWidget);
      
      // 4. 租赁流程测试
      await tester.tap(find.text('发现'));
      await tester.pumpAndSettle();
      
      await tester.tap(find.byType(ItemCard).first);
      await tester.pumpAndSettle();
      
      await tester.tap(find.text('立即租赁'));
      await tester.pumpAndSettle();
      
      // 选择租赁时间
      await tester.tap(find.byKey(Key('start_date_picker')));
      await tester.pumpAndSettle();
      await tester.tap(find.text('确定'));
      await tester.pumpAndSettle();
      
      await tester.tap(find.byKey(Key('end_date_picker')));
      await tester.pumpAndSettle();
      await tester.tap(find.text('确定'));
      await tester.pumpAndSettle();
      
      await tester.tap(find.text('确认租赁'));
      await tester.pumpAndSettle();
      
      expect(find.text('租赁成功'), findsOneWidget);
    });

    testWidgets('HarmonyOS特有功能测试', (WidgetTester tester) async {
      if (!Platform.isHarmonyOS) return;
      
      // HarmonyOS分布式能力测试
      await tester.pumpWidget(SharingCommunityApp());
      await tester.pumpAndSettle();
      
      // 1. 设备发现测试
      await tester.tap(find.byKey(Key('harmony_devices')));
      await tester.pumpAndSettle();
      
      expect(find.text('HarmonyOS设备'), findsOneWidget);
      
      // 模拟发现设备
      await tester.tap(find.text('扫描设备'));
      await tester.pump(Duration(seconds: 2));
      
      expect(find.byType(DeviceCard), findsWidgets);
      
      // 2. 分布式数据同步测试
      await tester.tap(find.byKey(Key('sync_data')));
      await tester.pumpAndSettle();
      
      // 测试数据同步
      final testData = {'test_key': 'test_value'};
      await tester.tap(find.text('开始同步'));
      await tester.pump(Duration(seconds: 1));
      
      expect(find.text('同步成功'), findsOneWidget);
      
      // 3. 原子化服务测试
      await tester.tap(find.byKey(Key('atomic_services')));
      await tester.pumpAndSettle();
      
      expect(find.text('原子化服务'), findsOneWidget);
      
      await tester.tap(find.text('快速共享'));
      await tester.pumpAndSettle();
      
      expect(find.text('选择共享内容'), findsOneWidget);
    });

    testWidgets('性能基准测试', (WidgetTester tester) async {
      // 启动性能测试
      final stopwatch = Stopwatch()..start();
      
      await tester.pumpWidget(SharingCommunityApp());
      await tester.pumpAndSettle();
      
      final startupTime = stopwatch.elapsedMilliseconds;
      print('应用启动时间: ${startupTime}ms');
      
      expect(startupTime, lessThan(2000)); // 启动时间应小于2秒
      
      // 列表滚动性能测试
      stopwatch.reset();
      await tester.fling(
        find.byType(ListView).first,
        Offset(0, -500),
        1000,
      );
      await tester.pumpAndSettle();
      
      final scrollTime = stopwatch.elapsedMilliseconds;
      print('列表滚动时间: ${scrollTime}ms');
      
      expect(scrollTime, lessThan(100)); // 滚动响应应小于100ms
      
      // 内存使用测试
      if (Platform.isAndroid || Platform.isIOS) {
        final memoryUsage = await PerformanceMonitor().getCurrentMemoryUsage();
        print('当前内存使用: ${memoryUsage}MB');
        
        expect(memoryUsage, lessThan(300)); // 内存使用应小于300MB
      }
    });
  });

  // HarmonyOS平台测试
  group('HarmonyOS平台测试', () {
    test('HarmonyOS API测试', () async {
      if (!Platform.isHarmonyOS) return;
      
      // 测试HarmonyOS通道
      final channel = MethodChannel('com.sharing.community/harmony');
      
      // 测试设备发现
      final devices = await channel.invokeMethod<List>('discoverDevices');
      expect(devices, isList);
      
      // 测试分布式数据
      final syncResult = await channel.invokeMethod<bool>('syncData', {
        'key': 'test',
        'value': 'test_value',
      });
      expect(syncResult, isTrue);
      
      // 测试原子化服务
      final serviceResult = await channel.invokeMethod<Map>('createService', {
        'name': 'test_service',
        'type': 'sharing',
      });
      expect(serviceResult, isNotNull);
      expect(serviceResult!['success'], isTrue);
    });
  });
}

第七章：部署与发布策略

7.1 多平台发布流程

// 发布管理器
class ReleaseManager {
  final Map<String, ReleasePlatform> _platforms;
  final ReleaseConfig _config;
  final AnalyticsService _analytics;
  
  ReleaseManager({
    required ReleaseConfig config,
    required AnalyticsService analytics,
  }) : _config = config,
       _analytics = analytics,
       _platforms = {} {
    _initializePlatforms();
  }
  
  void _initializePlatforms() {
    // Android平台
    _platforms['android'] = AndroidReleasePlatform(
      config: _config.androidConfig,
      keystore: _config.keystore,
    );
    
    // HarmonyOS平台
    _platforms['harmony'] = HarmonyReleasePlatform(
      config: _config.harmonyConfig,
      appGalleryConfig: _config.appGalleryConfig,
    );
    
    // Web平台
    _platforms['web'] = WebReleasePlatform(
      config: _config.webConfig,
      cdnConfig: _config.cdnConfig,
    );
  }
  
  // 准备发布
  Future<ReleasePreparation> prepareRelease({
    required String version,
    required String buildNumber,
    required ReleaseEnvironment environment,
    List<String>? targetPlatforms,
    Map<String, dynamic>? releaseNotes,
  }) async {
    final preparation = ReleasePreparation(
      version: version,
      buildNumber: buildNumber,
      environment: environment,
      startTime: DateTime.now(),
    );
    
    try {
      // 验证版本号
      await _validateVersion(version);
      
      // 构建应用
      final buildResults = await _buildApplications(
        version: version,
        buildNumber: buildNumber,
        environment: environment,
        platforms: targetPlatforms ?? _platforms.keys.toList(),
      );
      
      preparation.buildResults = buildResults;
      
      // 运行测试
      final testResults = await _runReleaseTests(
        buildResults: buildResults,
        environment: environment,
      );
      
      preparation.testResults = testResults;
      
      // 生成发布包
      final releasePackages = await _createReleasePackages(
        buildResults: buildResults,
        version: version,
        environment: environment,
        releaseNotes: releaseNotes,
      );
      
      preparation.releasePackages = releasePackages;
      preparation.status = ReleaseStatus.ready;
      
      // 记录准备事件
      await _analytics.logReleaseEvent(
        event: ReleaseEvent.prepared,
        preparation: preparation,
      );
      
      return preparation;
      
    } catch (e) {
      preparation.status = ReleaseStatus.failed;
      preparation.error = e.toString();
      
      await _analytics.logReleaseEvent(
        event: ReleaseEvent.failed,
        preparation: preparation,
        error: e,
      );
      
      rethrow;
    }
  }
  
  // 执行发布
  Future<ReleaseResult> executeRelease({
    required ReleasePreparation preparation,
    bool dryRun = false,
    bool rollbackOnError = true,
  }) async {
    final result = ReleaseResult(
      preparation: preparation,
      startTime: DateTime.now(),
      dryRun: dryRun,
    );
    
    try {
      // 1. 预发布检查
      await _preReleaseChecks(preparation);
      
      // 2. 分平台发布
      final platformResults = <String, PlatformReleaseResult>{};
      
      for (final platform in preparation.releasePackages!.keys) {
        if (!dryRun) {
          final platformResult = await _platforms[platform]!.release(
            package: preparation.releasePackages![platform]!,
            environment: preparation.environment,
            dryRun: dryRun,
          );
          
          platformResults[platform] = platformResult;
          
          // 记录平台发布事件
          await _analytics.logPlatformRelease(
            platform: platform,
            result: platformResult,
          );
        }
      }
      
      result.platformResults = platformResults;
      result.status = ReleaseStatus.completed;
      result.endTime = DateTime.now();
      
      // 3. 发布后操作
      if (!dryRun) {
        await _postReleaseOperations(result);
        
        // 发送发布通知
        await _sendReleaseNotifications(result);
      }
      
      // 记录成功事件
      await _analytics.logReleaseEvent(
        event: ReleaseEvent.completed,
        result: result,
      );
      
      return result;
      
    } catch (e) {
      result.status = ReleaseStatus.failed;
      result.error = e.toString();
      result.endTime = DateTime.now();
      
      // 错误处理
      if (rollbackOnError && !dryRun) {
        await _rollbackRelease(result);
      }
      
      // 记录失败事件
      await _analytics.logReleaseEvent(
        event: ReleaseEvent.failed,
        result: result,
        error: e,
      );
      
      // 发送错误通知
      await _sendErrorNotification(result);
      
      rethrow;
    }
  }
  
  // HarmonyOS AppGallery发布
  Future<AppGalleryReleaseResult> releaseToAppGallery({
    required String hapPath,
    required String version,
    required ReleaseEnvironment environment,
    AppGalleryReleaseConfig? config,
  }) async {
    final harmonyPlatform = _platforms['harmony'] as HarmonyReleasePlatform;
    
    return await harmonyPlatform.releaseToAppGallery(
      hapPath: hapPath,
      version: version,
      environment: environment,
      config: config ?? _config.appGalleryConfig,
    );
  }
}

// HarmonyOS发布平台
class HarmonyReleasePlatform extends ReleasePlatform {
  final HarmonyReleaseConfig config;
  final AppGalleryReleaseConfig appGalleryConfig;
  final HarmonyDevTools devTools;
  
  HarmonyReleasePlatform({
    required this.config,
    required this.appGalleryConfig,
  }) : devTools = HarmonyDevTools(config: config);
  
  @override
  Future<PlatformReleaseResult> release({
    required ReleasePackage package,
    required ReleaseEnvironment environment,
    bool dryRun = false,
  }) async {
    final result = PlatformReleaseResult(
      platform: 'harmony',
      package: package,
      environment: environment,
      startTime: DateTime.now(),
    );
    
    try {
      // 1. 验证HAP包
      await devTools.validateHap(package.path);
      
      // 2. 签名
      final signedPath = await devTools.signHap(
        hapPath: package.path,
        environment: environment,
      );
      
      // 3. 发布到测试环境
      if (environment != ReleaseEnvironment.production) {
        await _releaseToTestEnvironment(signedPath, environment);
      }
      
      // 4. 发布到AppGallery
      if (!dryRun && environment == ReleaseEnvironment.production) {
        final appGalleryResult = await _releaseToAppGallery(
          hapPath: signedPath,
          version: package.version,
          environment: environment,
        );
        
        result.appGalleryResult = appGalleryResult;
      }
      
      result.status = ReleaseStatus.completed;
      result.endTime = DateTime.now();
      
      return result;
      
    } catch (e) {
      result.status = ReleaseStatus.failed;
      result.error = e.toString();
      result.endTime = DateTime.now();
      
      rethrow;
    }
  }
  
  Future<AppGalleryReleaseResult> _releaseToAppGallery({
    required String hapPath,
    required String version,
    required ReleaseEnvironment environment,
  }) async {
    final client = AppGalleryConnectClient(
      clientId: appGalleryConfig.clientId,
      clientSecret: appGalleryConfig.clientSecret,
    );
    
    // 1. 上传HAP
    final uploadResult = await client.uploadApp(
      appId: appGalleryConfig.appId,
      hapPath: hapPath,
      version: version,
    );
    
    // 2. 提交审核
    final submitResult = await client.submitForReview(
      appId: appGalleryConfig.appId,
      versionId: uploadResult.versionId,
      releaseNotes: _getReleaseNotes(version, environment),
    );
    
    // 3. 更新服务卡片和原子化服务
    await _updateHarmonyServices(version);
    
    return AppGalleryReleaseResult(
      uploadResult: uploadResult,
      submitResult: submitResult,
      version: version,
      submittedAt: DateTime.now(),
    );
  }
  
  Future<void> _updateHarmonyServices(String version) async {
    // 更新服务卡片
    final cardManager = HarmonyCardManager(config: config);
    await cardManager.updateServiceCards(version);
    
    // 更新原子化服务
    final serviceManager = HarmonyServiceManager(config: config);
    await serviceManager.updateAtomicServices(version);
    
    // 同步分布式配置
    final distributedManager = HarmonyDistributedManager(config: config);
    await distributedManager.syncConfiguration(version);
  }
}

7.2 监控与数据分析

// 发布监控仪表板
class ReleaseDashboard extends StatefulWidget {
  final String? environment;
  
  const ReleaseDashboard({this.environment});
  
  @override
  _ReleaseDashboardState createState() => _ReleaseDashboardState();
}

class _ReleaseDashboardState extends State<ReleaseDashboard> {
  final ReleaseMonitor _monitor = ReleaseMonitor();
  List<ReleaseEvent> _events = [];
  Map<String, dynamic> _metrics = {};
  bool _isLoading = true;
  
  @override
  void initState() {
    super.initState();
    _loadData();
    _startRealtimeUpdates();
  }
  
  Future<void> _loadData() async {
    setState(() => _isLoading = true);
    
    try {
      final events = await _monitor.getReleaseEvents(
        environment: widget.environment,
        limit: 50,
      );
      
      final metrics = await _monitor.getReleaseMetrics(
        environment: widget.environment,
        period: Period.last7Days,
      );
      
      setState(() {
        _events = events;
        _metrics = metrics;
        _isLoading = false;
      });
    } catch (e) {
      setState(() => _isLoading = false);
      print('加载数据失败: $e');
    }
  }
  
  void _startRealtimeUpdates() {
    _monitor.releaseStream.listen((event) {
      setState(() {
        _events.insert(0, event);
      });
    });
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('发布监控'),
        actions: [
          IconButton(
            icon: Icon(Icons.refresh),
            onPressed: _loadData,
          ),
        ],
      ),
      body: _isLoading
          ? Center(child: CircularProgressIndicator())
          : _buildDashboard(),
    );
  }
  
  Widget _buildDashboard() {
    return SingleChildScrollView(
      child: Column(
        children: [
          // 关键指标
          _buildMetricsSection(),
          
          // 发布事件时间线
          _buildTimelineSection(),
          
          // 平台状态
          _buildPlatformStatusSection(),
          
          // 性能数据
          _buildPerformanceSection(),
        ],
      ),
    );
  }
  
  Widget _buildMetricsSection() {
    return Card(
      child: Padding(
        padding: EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text('发布指标', style: Theme.of(context).textTheme.headline6),
            SizedBox(height: 16),
            Row(
              children: [
                _buildMetricCard(
                  title: '成功发布',
                  value: '${_metrics['success_count'] ?? 0}',
                  color: Colors.green,
                ),
                SizedBox(width: 16),
                _buildMetricCard(
                  title: '失败发布',
                  value: '${_metrics['failure_count'] ?? 0}',
                  color: Colors.red,
                ),
                SizedBox(width: 16),
                _buildMetricCard(
                  title: '平均发布时间',
                  value: '${_metrics['avg_duration'] ?? 0}s',
                  color: Colors.blue,
                ),
              ],
            ),
          ],
        ),
      ),
    );
  }
  
  Widget _buildMetricCard({
    required String title,
    required String value,
    required Color color,
  }) {
    return Expanded(
      child: Container(
        padding: EdgeInsets.all(12),
        decoration: BoxDecoration(
          color: color.withOpacity(0.1),
          borderRadius: BorderRadius.circular(8),
        ),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(title, style: TextStyle(fontSize: 12, color: Colors.grey)),
            SizedBox(height: 4),
            Text(value, style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold)),
          ],
        ),
      ),
    );
  }
  
  Widget _buildTimelineSection() {
    return Card(
      child: Padding(
        padding: EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text('发布时间线', style: Theme.of(context).textTheme.headline6),
            SizedBox(height: 16),
            ..._events.take(10).map(_buildTimelineItem).toList(),
          ],
        ),
      ),
    );
  }
  
  Widget _buildTimelineItem(ReleaseEvent event) {
    return ListTile(
      leading: Container(
        width: 12,
        height: 12,
        decoration: BoxDecoration(
          color: event.status == ReleaseStatus.completed
              ? Colors.green
              : event.status == ReleaseStatus.failed
                  ? Colors.red
                  : Colors.orange,
          shape: BoxShape.circle,
        ),
      ),
      title: Text(event.description),
      subtitle: Text(
        '${event.timestamp.toLocal()} • ${event.platform ?? '所有平台'}',
      ),
      trailing: event.duration != null
          ? Text('${event.duration!.inSeconds}s')
          : null,
    );
  }
}

第八章：总结与展望

8.1 技术成果总结

通过Flutter与HarmonyOS的一体化开发实践，我们在"共享社区"类应用的开发中取得了以下技术成果：

开发效率提升

// 代码复用率统计
class CodeReuseMetrics {
  static const metrics = {
    'business_logic': {
      'reuse_rate': 0.92,  // 业务逻辑复用率92%
      'platform_specific': 0.08,
      'total_lines': 15420,
    },
    'ui_components': {
      'reuse_rate': 0.85,  // UI组件复用率85%
      'platform_specific': 0.15,
      'total_components': 87,
    },
    'data_models': {
      'reuse_rate': 1.00,  // 数据模型复用率100%
      'platform_specific': 0.00,
      'total_models': 23,
    },
  };
  
  // 开发时间对比
  static const developmentTime = {
    'traditional': {
      'android': 60,  // 60人天
      'ios': 55,      // 55人天
      'harmony': 50,  // 50人天
      'total': 165,   // 总人天
    },
    'flutter_harmony': {
      'shared_code': 70,    // 共享代码70人天
      'android_specific': 5, // Android特定5人天
      'ios_specific': 5,    // iOS特定5人天
      'harmony_specific': 10, // HarmonyOS特定10人天
      'total': 90,          // 总人天90
    },
    'time_saving': {
      'absolute': 75,       // 节省75人天
      'percentage': 0.45,   // 节省45%
    },
  };
}

性能表现优化

// 性能对比数据
class PerformanceComparison {
  static const android = {
    'startup_time': {
      'native': 1200,  // 原生：1200ms
      'flutter': 1400, // Flutter：1400ms
      'optimized': 1100, // 优化后：1100ms
    },
    'fps': {
      'native': 58,    // 原生：58fps
      'flutter': 55,   // Flutter：55fps
      'optimized': 57, // 优化后：57fps
    },
    'memory_usage': {
      'native': 220,   // 原生：220MB
      'flutter': 280,  // Flutter：280MB
      'optimized': 240, // 优化后：240MB
    },
  };
  
  static const harmony = {
    'startup_time': {
      'native_arkui': 900,   // 原生ArkUI：900ms
      'flutter': 1300,       // Flutter：1300ms
      'optimized': 950,      // 优化后：950ms
    },
    'distributed_performance': {
      'data_sync_latency': 50,  // 数据同步延迟：50ms
      'device_discovery': 200,  // 设备发现：200ms
      'cross_device_control': 100, // 跨设备控制：100ms
    },
  };
}

8.2 未来演进方向

技术演进路线图

关键技术趋势

1. AI驱动的开发体验

   • 智能代码补全和生成
   • 自动化性能优化建议
   • 智能测试用例生成

2. AR/VR融合体验

   • 虚拟物品预览
   • AR空间共享
   • 沉浸式交易体验

3. 边缘计算集成

   • 本地AI推理
   • 离线优先架构
   • 边缘设备协同

4. 云原生开发范式

   • 服务端驱动UI
   • 动态能力更新
   • 无服务器架构

8.3 实施建议

团队建设建议

// 团队技能矩阵
class TeamSkillMatrix {
  static const requiredSkills = {
    'flutter_expert': {
      'description': 'Flutter框架专家',
      'required_level': 5,
      'responsibilities': [
        '架构设计',
        '性能优化',
        '复杂组件开发',
      ],
    },
    'harmony_specialist': {
      'description': 'HarmonyOS专家',
      'required_level': 4,
      'responsibilities': [
        '分布式能力开发',
        '原子化服务',
        '原生能力集成',
      ],
    },
    'full_stack': {
      'description': '全栈工程师',
      'required_level': 3,
      'responsibilities': [
        '前后端开发',
        'API设计',
        '数据库优化',
      ],
    },
    'qa_engineer': {
      'description': '质量保证工程师',
      'required_level': 3,
      'responsibilities': [
        '自动化测试',
        '性能监控',
        '质量度量',
      ],
    },
  };
  
  // 培训计划
  static const trainingPlan = {
    'phase_1': {
      'duration': '1个月',
      'topics': [
        'Flutter核心概念',
        'Dart高级特性',
        '状态管理',
      ],
    },
    'phase_2': {
      'duration': '2个月',
      'topics': [
        'HarmonyOS架构',
        '分布式开发',
        '平台通道',
      ],
    },
    'phase_3': {
      'duration': '1个月',
      'topics': [
        '性能优化',
        '安全实践',
        '团队协作',
      ],
    },
  };
}

项目管理建议

1. 迭代开发策略

   • 采用双周迭代周期
   • 特性驱动的开发流程
   • 持续集成/持续部署

2. 质量保障体系

   • 自动化测试覆盖率达到80%+
   • 代码审查制度
   • 性能基准测试

3. 风险管理

   • 技术债务管理
   • 依赖版本控制
   • 回滚策略制定

8.4 结语

通过Flutter与HarmonyOS的一体化开发实践，我们不仅实现了"共享社区"类应用的高效开发和多平台部署，更重要的是探索出了一条符合中国技术生态的跨平台开发新路径。

核心价值总结：

1. 技术融合创新：Flutter的跨平台能力与HarmonyOS的分布式特性完美结合
2. 开发效率革命：代码复用率大幅提升，开发周期显著缩短
3. 用户体验突破：利用HarmonyOS原生能力提供差异化体验
4. 生态建设贡献：为Flutter-HarmonyOS生态建设提供了实践案例

未来展望：

随着HarmonyOS生态的不断完善和Flutter技术的持续演进，这种一体化开发模式将在更多应用场景中发挥价值。我们期待看到更多开发者加入这个生态，共同推动中国移动应用开发技术的前进。

"共享社区"不仅是一个应用，更是技术融合创新的实践平台。通过这个项目，我们证明了Flutter与HarmonyOS结合的巨大潜力，为行业提供了可复制、可推广的技术方案。

让我们共同期待，在技术的驱动下，共享经济的未来将更加智能、高效、普惠。

如果您有任何疑问、对文章写的不满意、发现错误或者有更好的方法，欢迎在评论、私信或邮件中提出，非常感谢您的支持。🙏
嘻嘻嘻，关注我！！！黑马波哥
也可以关注我的抖音号: 黑马程序员burger(50696424331) 在直播间交流(18:00-21:00)