Flutter发布与部署 #

// config/environment.dart
enum Environment { dev, staging, prod }

class AppConfig {
  static Environment _env = Environment.prod;

  static void setEnvironment(Environment env) {
    _env = env;
  }

  static String get baseUrl {
    switch (_env) {
      case Environment.dev:
        return 'https://api-dev.example.com';
      case Environment.staging:
        return 'https://api-staging.example.com';
      case Environment.prod:
        return 'https://api.example.com';
    }
  }

  static bool get enableLogging {
    return _env != Environment.prod;
  }

  static bool get enableDebugFeatures {
    return _env != Environment.prod;
  }
}

// main_dev.dart
import 'config/environment.dart';

void main() {
  AppConfig.setEnvironment(Environment.dev);
  runApp(MyApp());
}

// main_prod.dart
import 'config/environment.dart';

void main() {
  AppConfig.setEnvironment(Environment.prod);
  runApp(MyApp());
}

// services/error_reporting_service.dart
import 'package:firebase_crashlytics/firebase_crashlytics.dart';

class ErrorReportingService {
  static Future<void> init() async {
    // 启用Firebase Crashlytics
    await FirebaseCrashlytics.instance.setCrashlyticsCollectionEnabled(true);
    
    // 设置错误处理
    FlutterError.onError = (FlutterErrorDetails details) {
      FirebaseCrashlytics.instance.recordFlutterError(details);
    };
    
    // 捕获未处理异常
    PlatformDispatcher.instance.onError = (Object error, StackTrace stack) {
      FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
      return true;
    };
  }

  static void recordError(dynamic error, StackTrace stackTrace) {
    FirebaseCrashlytics.instance.recordError(error, stackTrace);
  }

  static void recordNonFatalError(dynamic error, StackTrace stackTrace) {
    FirebaseCrashlytics.instance.recordError(error, stackTrace);
  }
}

// services/performance_monitoring_service.dart
import 'package:firebase_performance/firebase_performance.dart';

class PerformanceMonitoringService {
  static final _perf = FirebasePerformance.instance;

  static Future<void> startTrace(String traceName) async {
    final trace = _perf.newTrace(traceName);
    await trace.start();
  }

  static Future<void> stopTrace(String traceName) async {
    final trace = _perf.getTrace(traceName);
    await trace.stop();
  }

  static Future<String> observeHttpTracing(Uri uri) async {
    final httpMetric = _perf.newHttpMetric(uri, HttpMethod.Get);
    await httpMetric.start();
    
    // 执行HTTP请求
    final response = await http.get(uri);
    
    // 设置响应数据
    httpMetric.responseContentType = response.headers['content-type'];
    httpMetric.responsePayloadSize = response.body.length;
    httpMetric.httpResponseCode = response.statusCode;
    
    await httpMetric.stop();
    
    return response.body;
  }
}

// 现代替代方案：使用Flutter的动态功能或云函数
class DynamicFeatureService {
  static Future<void> checkForUpdates() async {
    // 实现动态更新检查逻辑
    // 可以结合Firebase Remote Config或其他后端服务
  }
}

// services/remote_config_service.dart
import 'package:firebase_remote_config/firebase_remote_config.dart';

class RemoteConfigService {
  static final RemoteConfig _remoteConfig = RemoteConfig.instance;

  static Future<void> init() async {
    // 设置默认值
    await _remoteConfig.setDefaults(<String, dynamic>{
      'show_feature_x': true,
      'feature_x_threshold': 100,
      'welcome_message': 'Welcome!',
    });

    // 获取配置（有超时设置）
    await _remoteConfig.fetchAndActivate();
  }

  static bool getBool(String key) {
    return _remoteConfig.getBool(key);
  }

  static int getInt(String key) {
    return _remoteConfig.getInt(key);
  }

  static String getString(String key) {
    return _remoteConfig.getString(key);
  }
}

// services/feedback_service.dart
import 'package:firebase_analytics/firebase_analytics.dart';

class FeedbackService {
  static final analytics = FirebaseAnalytics.instance;

  static Future<void> logUserAction(String action, Map<String, dynamic>? params) async {
    await analytics.logEvent(name: action, parameters: params);
  }

  static Future<void> logScreenView(String screenName) async {
    await analytics.logScreenView(screenName: screenName);
  }

  static Future<void> setUserProperty(String name, String value) async {
    await analytics.setUserProperty(name: name, value: value);
  }
}

// 性能监控工具类
class PerformanceChecker {
  static void measureFunction(String name, Function fn) {
    final start = DateTime.now();
    fn();
    final end = DateTime.now();
    final duration = end.difference(start);
    
    if (duration.inMilliseconds > 16) {
      print('Performance warning: $name took ${duration.inMilliseconds}ms');
    }
  }
}